vectorvein 0.2.96__tar.gz → 0.2.98__tar.gz

{vectorvein-0.2.96 → vectorvein-0.2.98}/PKG-INFO

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

{vectorvein-0.2.96 → vectorvein-0.2.98}/pyproject.toml

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

{vectorvein-0.2.96 → vectorvein-0.2.98}/src/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-0.2.96 → vectorvein-0.2.98}/src/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)
@@ -820,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,
@@ -855,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:
@@ -878,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)

{vectorvein-0.2.96 → vectorvein-0.2.98}/src/vectorvein/types/defaults.py

@@ -996,6 +996,14 @@ GEMINI_MODELS: Final[Dict[str, ModelSettingDict]] = {
         "response_format_available": True,
         "native_multimodal": True,
     },
+    "gemini-2.5-pro-preview-06-05": {
+        "id": "gemini-2.5-pro-preview-06-05",
+        "context_length": 1048576,
+        "max_output_tokens": 65536,
+        "function_call_available": True,
+        "response_format_available": True,
+        "native_multimodal": True,
+    },
 }
 
 # 百度文心一言 ERNIE 模型

{vectorvein-0.2.96 → vectorvein-0.2.98}/src/vectorvein/workflow/nodes/image_generation.py

@@ -182,6 +182,16 @@ class Flux1(Node):
                     value="",
                     multiple=True,
                 ),
+                "input_image": InputPort(
+                    name="input_image",
+                    port_type=PortType.FILE,
+                    value=list(),
+                    support_file_types=[".jpg", ".jpeg", ".png", ".webp"],
+                    multiple=True,
+                    show=True,
+                    condition="return fieldsData.model.value.startsWith('FLUX.1 Kontext')",
+                    condition_python=lambda ports: ports["model"].value.startswith("FLUX.1 Kontext"),
+                ),
                 "model": InputPort(
                     name="model",
                     port_type=PortType.SELECT,
@@ -191,6 +201,9 @@ class Flux1(Node):
                         {"value": "FLUX.1 [dev]", "label": "FLUX.1 [dev]"},
                         {"value": "FLUX.1 [pro]", "label": "FLUX.1 [pro]"},
                         {"value": "FLUX.1 [pro] ultra", "label": "FLUX.1 [pro] ultra"},
+                        {"value": "FLUX.1 Kontext [pro]", "label": "FLUX.1 Kontext [pro]"},
+                        {"value": "FLUX.1 Kontext [max]", "label": "FLUX.1 Kontext [max]"},
+                        {"value": "FLUX.1 Kontext [max] Multi", "label": "FLUX.1 Kontext [max] Multi"},
                     ],
                     multiple=True,
                 ),
@@ -199,16 +212,16 @@ class Flux1(Node):
                     port_type=PortType.NUMBER,
                     value=1024,
                     max=1536,
-                    condition="return fieldsData.model.value !== 'FLUX.1 [pro] ultra'",
-                    condition_python=lambda ports: ports["model"].value != "FLUX.1 [pro] ultra",
+                    condition="return fieldsData.model.value !== 'FLUX.1 [pro] ultra' && !fieldsData.model.value.startsWith('FLUX.1 Kontext')",
+                    condition_python=lambda ports: ports["model"].value != "FLUX.1 [pro] ultra" and not ports["model"].value.startswith("FLUX.1 Kontext"),
                 ),
                 "height": InputPort(
                     name="height",
                     port_type=PortType.NUMBER,
                     value=1024,
                     max=1536,
-                    condition="return fieldsData.model.value !== 'FLUX.1 [pro] ultra'",
-                    condition_python=lambda ports: ports["model"].value != "FLUX.1 [pro] ultra",
+                    condition="return fieldsData.model.value !== 'FLUX.1 [pro] ultra' && !fieldsData.model.value.startsWith('FLUX.1 Kontext')",
+                    condition_python=lambda ports: ports["model"].value != "FLUX.1 [pro] ultra" and not ports["model"].value.startswith("FLUX.1 Kontext"),
                 ),
                 "aspect_ratio": InputPort(
                     name="aspect_ratio",
@@ -374,10 +387,7 @@ class Kolors(Node):
                         {"value": "EulerDiscreteScheduler", "label": "EulerDiscreteScheduler"},
                         {"value": "EulerAncestralDiscreteScheduler", "label": "EulerAncestralDiscreteScheduler"},
                         {"value": "DPMSolverMultistepScheduler", "label": "DPMSolverMultistepScheduler"},
-                        {
-                            "value": "DPMSolverMultistepScheduler_SDE_karras",
-                            "label": "DPMSolverMultistepScheduler_SDE_karras",
-                        },
+                        {"value": "DPMSolverMultistepScheduler_SDE_karras", "label": "DPMSolverMultistepScheduler_SDE_karras"},
                         {"value": "UniPCMultistepScheduler", "label": "UniPCMultistepScheduler"},
                         {"value": "DEISMultistepScheduler", "label": "DEISMultistepScheduler"},
                     ],
@@ -566,8 +576,7 @@ class Recraft(Node):
                         {"value": "motion_blur", "label": "motion_blur"},
                     ],
                     condition="return fieldsData.generation_type.value === 'text_to_image' && fieldsData.base_style.value === 'realistic_image'",
-                    condition_python=lambda ports: ports["generation_type"].value == "text_to_image"
-                    and ports["base_style"].value == "realistic_image",
+                    condition_python=lambda ports: ports["generation_type"].value == "text_to_image" and ports["base_style"].value == "realistic_image",
                     multiple=True,
                 ),
                 "substyle_digital_illustration": InputPort(
@@ -587,8 +596,7 @@ class Recraft(Node):
                         {"value": "2d_art_poster_2", "label": "2d_art_poster_2"},
                     ],
                     condition="return fieldsData.generation_type.value === 'text_to_image' && fieldsData.base_style.value === 'digital_illustration'",
-                    condition_python=lambda ports: ports["generation_type"].value == "text_to_image"
-                    and ports["base_style"].value == "digital_illustration",
+                    condition_python=lambda ports: ports["generation_type"].value == "text_to_image" and ports["base_style"].value == "digital_illustration",
                     multiple=True,
                 ),
                 "substyle_vector_illustration": InputPort(
@@ -603,8 +611,7 @@ class Recraft(Node):
                         {"value": "linocut", "label": "linocut"},
                     ],
                     condition="return fieldsData.generation_type.value === 'text_to_image' && fieldsData.base_style.value === 'vector_illustration'",
-                    condition_python=lambda ports: ports["generation_type"].value == "text_to_image"
-                    and ports["base_style"].value == "vector_illustration",
+                    condition_python=lambda ports: ports["generation_type"].value == "text_to_image" and ports["base_style"].value == "vector_illustration",
                     multiple=True,
                 ),
                 "size": InputPort(
@@ -663,6 +670,107 @@ class Recraft(Node):
         )
 
 
+class GptImage(Node):
+    def __init__(self, id: Optional[str] = None):
+        super().__init__(
+            node_type="GptImage",
+            category="image_generation",
+            task_name="image_generation.gpt_image",
+            node_id=id,
+            ports={
+                "action": InputPort(
+                    name="action",
+                    port_type=PortType.SELECT,
+                    value="generation",
+                    options=[
+                        {"value": "generation", "label": "generation"},
+                        {"value": "edit", "label": "edit"},
+                    ],
+                ),
+                "prompt": InputPort(
+                    name="prompt",
+                    port_type=PortType.TEXTAREA,
+                    value="",
+                    multiple=True,
+                    show=True,
+                ),
+                "individual_images": InputPort(
+                    name="individual_images",
+                    port_type=PortType.CHECKBOX,
+                    value=False,
+                    condition="return fieldsData.action.value === 'edit'",
+                    condition_python=lambda ports: ports["action"].value == "edit",
+                ),
+                "image": InputPort(
+                    name="image",
+                    port_type=PortType.FILE,
+                    value=list(),
+                    support_file_types=[".jpg", ".jpeg", ".png", ".webp"],
+                    multiple=False,
+                    condition="return fieldsData.action.value === 'edit'",
+                    condition_python=lambda ports: ports["action"].value == "edit",
+                ),
+                "mask": InputPort(
+                    name="mask",
+                    port_type=PortType.FILE,
+                    value=list(),
+                    support_file_types=[".png"],
+                    condition="return fieldsData.action.value === 'edit'",
+                    condition_python=lambda ports: ports["action"].value == "edit",
+                ),
+                "model": InputPort(
+                    name="model",
+                    port_type=PortType.SELECT,
+                    value="gpt-image-1",
+                    options=[
+                        {"value": "gpt-image-1", "label": "gpt-image-1"},
+                    ],
+                    multiple=True,
+                ),
+                "size": InputPort(
+                    name="size",
+                    port_type=PortType.SELECT,
+                    value="1024x1024",
+                    options=[
+                        {"value": "1024x1024", "label": "1024x1024"},
+                        {"value": "1024x1536", "label": "1024x1536"},
+                        {"value": "1536x1024", "label": "1536x1024"},
+                    ],
+                    multiple=True,
+                ),
+                "n": InputPort(
+                    name="n",
+                    port_type=PortType.NUMBER,
+                    value=1,
+                    min=1,
+                    max=10,
+                ),
+                "quality": InputPort(
+                    name="quality",
+                    port_type=PortType.SELECT,
+                    value="high",
+                    options=[
+                        {"value": "low", "label": "low"},
+                        {"value": "medium", "label": "medium"},
+                        {"value": "high", "label": "high"},
+                    ],
+                    multiple=True,
+                ),
+                "output_type": InputPort(
+                    name="output_type",
+                    port_type=PortType.SELECT,
+                    value="markdown",
+                    options=[
+                        {"value": "only_link", "label": "only_link"},
+                        {"value": "markdown", "label": "markdown"},
+                        {"value": "html", "label": "html"},
+                    ],
+                ),
+                "output": OutputPort(),
+            },
+        )
+
+
 class StableDiffusion(Node):
     def __init__(self, id: Optional[str] = None):
         special_width_height_models = [

{vectorvein-0.2.96 → vectorvein-0.2.98}/src/vectorvein/workflow/nodes/llms.py

@@ -21,15 +21,31 @@ class AliyunQwen(Node):
                 "llm_model": InputPort(
                     name="llm_model",
                     port_type=PortType.SELECT,
-                    value="qwen2.5-72b-instruct",
+                    value="qwen3-32b",
                     options=[
                         {"value": "qwen2.5-72b-instruct", "label": "qwen2.5-72b-instruct"},
                         {"value": "qwen2.5-32b-instruct", "label": "qwen2.5-32b-instruct"},
                         {"value": "qwen2.5-coder-32b-instruct", "label": "qwen2.5-coder-32b-instruct"},
-                        {"value": "qwq-32b-preview", "label": "qwq-32b-preview"},
+                        {"value": "qwq-32b", "label": "qwq-32b"},
                         {"value": "qwen2.5-14b-instruct", "label": "qwen2.5-14b-instruct"},
                         {"value": "qwen2.5-7b-instruct", "label": "qwen2.5-7b-instruct"},
                         {"value": "qwen2.5-coder-7b-instruct", "label": "qwen2.5-coder-7b-instruct"},
+                        {"value": "qwen3-235b-a22b", "label": "qwen3-235b-a22b"},
+                        {"value": "qwen3-235b-a22b-thinking", "label": "qwen3-235b-a22b-thinking"},
+                        {"value": "qwen3-32b", "label": "qwen3-32b"},
+                        {"value": "qwen3-32b-thinking", "label": "qwen3-32b-thinking"},
+                        {"value": "qwen3-30b-a3b", "label": "qwen3-30b-a3b"},
+                        {"value": "qwen3-30b-a3b-thinking", "label": "qwen3-30b-a3b-thinking"},
+                        {"value": "qwen3-14b", "label": "qwen3-14b"},
+                        {"value": "qwen3-14b-thinking", "label": "qwen3-14b-thinking"},
+                        {"value": "qwen3-8b", "label": "qwen3-8b"},
+                        {"value": "qwen3-8b-thinking", "label": "qwen3-8b-thinking"},
+                        {"value": "qwen3-4b", "label": "qwen3-4b"},
+                        {"value": "qwen3-4b-thinking", "label": "qwen3-4b-thinking"},
+                        {"value": "qwen3-1.7b", "label": "qwen3-1.7b"},
+                        {"value": "qwen3-1.7b-thinking", "label": "qwen3-1.7b-thinking"},
+                        {"value": "qwen3-0.6b", "label": "qwen3-0.6b"},
+                        {"value": "qwen3-0.6b-thinking", "label": "qwen3-0.6b-thinking"},
                     ],
                 ),
                 "top_p": InputPort(
@@ -180,6 +196,7 @@ class BaiduWenxin(Node):
                         {"value": "ernie-speed", "label": "ernie-speed"},
                         {"value": "ernie-3.5", "label": "ernie-3.5"},
                         {"value": "ernie-4.0", "label": "ernie-4.0"},
+                        {"value": "ernie-4.5", "label": "ernie-4.5"},
                     ],
                 ),
                 "temperature": InputPort(
@@ -224,6 +241,9 @@ class ChatGLM(Node):
                         {"value": "glm-4-flash", "label": "glm-4-flash"},
                         {"value": "glm-4-long", "label": "glm-4-long"},
                         {"value": "glm-zero-preview", "label": "glm-zero-preview"},
+                        {"value": "glm-z1-air", "label": "glm-z1-air"},
+                        {"value": "glm-z1-airx", "label": "glm-z1-airx"},
+                        {"value": "glm-z1-flash", "label": "glm-z1-flash"},
                     ],
                 ),
                 "temperature": InputPort(
@@ -299,8 +319,12 @@ class Claude(Node):
                 "llm_model": InputPort(
                     name="llm_model",
                     port_type=PortType.SELECT,
-                    value="claude-3-5-haiku",
+                    value="claude-sonnet-4-20250514",
                     options=[
+                        {"value": "claude-opus-4-20250514-thinking", "label": "claude-opus-4-20250514-thinking"},
+                        {"value": "claude-opus-4-20250514", "label": "claude-opus-4-20250514"},
+                        {"value": "claude-sonnet-4-20250514-thinking", "label": "claude-sonnet-4-20250514-thinking"},
+                        {"value": "claude-sonnet-4-20250514", "label": "claude-sonnet-4-20250514"},
                         {"value": "claude-3-7-sonnet-thinking", "label": "claude-3-7-sonnet-thinking"},
                         {"value": "claude-3-7-sonnet", "label": "claude-3-7-sonnet"},
                         {"value": "claude-3-5-sonnet", "label": "claude-3-5-sonnet"},
@@ -441,21 +465,13 @@ class Gemini(Node):
                 "llm_model": InputPort(
                     name="llm_model",
                     port_type=PortType.SELECT,
-                    value="gemini-1.5-flash",
+                    value="gemini-2.5-pro-preview-06-05",
                     options=[
-                        {"value": "gemini-1.5-flash", "label": "gemini-1.5-flash"},
-                        {"value": "gemini-1.5-pro", "label": "gemini-1.5-pro"},
-                        {"value": "gemini-2.0-flash", "label": "gemini-2.0-flash"},
-                        {
-                            "value": "gemini-2.0-flash-thinking-exp-01-21",
-                            "label": "gemini-2.0-flash-thinking-exp-01-21",
-                        },
-                        {"value": "gemini-2.0-pro-exp-02-05", "label": "gemini-2.0-pro-exp-02-05"},
-                        {
-                            "value": "gemini-2.0-flash-lite-preview-02-05",
-                            "label": "gemini-2.0-flash-lite-preview-02-05",
-                        },
-                        {"value": "gemini-exp-1206", "label": "gemini-exp-1206"},
+                        {"label": "gemini-2.0-flash", "value": "gemini-2.0-flash"},
+                        {"label": "gemini-2.0-flash-lite-preview-02-05", "value": "gemini-2.0-flash-lite-preview-02-05"},
+                        {"value": "gemini-2.0-flash-thinking-exp-01-21", "label": "gemini-2.0-flash-thinking-exp-01-21"},
+                        {"label": "gemini-2.5-pro-preview-06-05", "value": "gemini-2.5-pro-preview-06-05"},
+                        {"label": "gemini-2.5-flash-preview-05-20", "value": "gemini-2.5-flash-preview-05-20"},
                     ],
                 ),
                 "temperature": InputPort(
@@ -678,6 +694,7 @@ class Moonshot(Node):
                         {"value": "moonshot-v1-8k", "label": "moonshot-v1-8k"},
                         {"value": "moonshot-v1-32k", "label": "moonshot-v1-32k"},
                         {"value": "moonshot-v1-128k", "label": "moonshot-v1-128k"},
+                        {"value": "kimi-latest", "label": "kimi-latest"},
                     ],
                 ),
                 "temperature": InputPort(
@@ -771,6 +788,10 @@ class OpenAI(Node):
                         {"value": "o1-mini", "label": "o1-mini"},
                         {"value": "o1-preview", "label": "o1-preview"},
                         {"value": "o3-mini", "label": "o3-mini"},
+                        {"value": "o3-mini-high", "label": "o3-mini-high"},
+                        {"value": "gpt-4.1", "label": "gpt-4.1"},
+                        {"value": "o4-mini", "label": "o4-mini"},
+                        {"value": "o4-mini-high", "label": "o4-mini-high"},
                     ],
                 ),
                 "temperature": InputPort(
@@ -855,9 +876,13 @@ class XAi(Node):
                 "llm_model": InputPort(
                     name="llm_model",
                     port_type=PortType.SELECT,
-                    value="grok-beta",
+                    value="grok-3-beta",
                     options=[
                         {"value": "grok-beta", "label": "grok-beta"},
+                        {"value": "grok-3-beta", "label": "grok-3-beta"},
+                        {"value": "grok-3-fast-beta", "label": "grok-3-fast-beta"},
+                        {"value": "grok-3-mini-beta", "label": "grok-3-mini-beta"},
+                        {"value": "grok-3-mini-fast-beta", "label": "grok-3-mini-fast-beta"},
                     ],
                 ),
                 "temperature": InputPort(

{vectorvein-0.2.96 → vectorvein-0.2.98}/src/vectorvein/workflow/nodes/media_processing.py

@@ -21,8 +21,14 @@ class ClaudeVision(Node):
                 "llm_model": InputPort(
                     name="llm_model",
                     port_type=PortType.SELECT,
-                    value="claude-3-5-sonnet",
+                    value="claude-sonnet-4-20250514",
                     options=[
+                        {"value": "claude-opus-4-20250514-thinking", "label": "claude-opus-4-20250514-thinking"},
+                        {"value": "claude-opus-4-20250514", "label": "claude-opus-4-20250514"},
+                        {"value": "claude-sonnet-4-20250514-thinking", "label": "claude-sonnet-4-20250514-thinking"},
+                        {"value": "claude-sonnet-4-20250514", "label": "claude-sonnet-4-20250514"},
+                        {"value": "claude-3-7-sonnet-thinking", "label": "claude-3-7-sonnet-thinking"},
+                        {"value": "claude-3-7-sonnet", "label": "claude-3-7-sonnet"},
                         {"value": "claude-3-5-sonnet", "label": "claude-3-5-sonnet"},
                         {"value": "claude-3-opus", "label": "claude-3-opus"},
                         {"value": "claude-3-sonnet", "label": "claude-3-sonnet"},
@@ -134,13 +140,13 @@ class GeminiVision(Node):
                 "llm_model": InputPort(
                     name="llm_model",
                     port_type=PortType.SELECT,
-                    value="gemini-1.5-pro",
+                    value="gemini-2.5-pro-preview-06-05",
                     options=[
-                        {"value": "gemini-1.5-pro", "label": "gemini-1.5-pro"},
-                        {"value": "gemini-1.5-flash", "label": "gemini-1.5-flash"},
-                        {"value": "gemini-2.0-flash-exp", "label": "gemini-2.0-flash-exp"},
-                        {"value": "gemini-2.0-flash-thinking-exp-1219", "label": "gemini-2.0-flash-thinking-exp-1219"},
-                        {"value": "gemini-exp-1206", "label": "gemini-exp-1206"},
+                        {"label": "gemini-2.0-flash", "value": "gemini-2.0-flash"},
+                        {"label": "gemini-2.0-flash-lite-preview-02-05", "value": "gemini-2.0-flash-lite-preview-02-05"},
+                        {"value": "gemini-2.0-flash-thinking-exp-01-21", "label": "gemini-2.0-flash-thinking-exp-01-21"},
+                        {"label": "gemini-2.5-pro-preview-06-05", "value": "gemini-2.5-pro-preview-06-05"},
+                        {"label": "gemini-2.5-flash-preview-05-20", "value": "gemini-2.5-flash-preview-05-20"},
                     ],
                 ),
                 "multiple_input": InputPort(
@@ -254,6 +260,9 @@ class GptVision(Node):
                     options=[
                         {"value": "gpt-4o", "label": "gpt-4o"},
                         {"value": "gpt-4o-mini", "label": "gpt-4o-mini"},
+                        {"value": "o4-mini", "label": "o4-mini"},
+                        {"value": "o4-mini-high", "label": "o4-mini-high"},
+                        {"value": "gpt-4.1", "label": "gpt-4.1"},
                     ],
                 ),
                 "images_or_urls": InputPort(

{vectorvein-0.2.96 → vectorvein-0.2.98}/src/vectorvein/workflow/nodes/output.py

@@ -332,16 +332,14 @@ class PictureRender(Node):
                     port_type=PortType.NUMBER,
                     value=1200,
                     condition="return ['url', 'html_code', 'markdown', 'mindmap', 'mermaid'].includes(fieldsData.render_type.value)",
-                    condition_python=lambda ports: ports["render_type"].value
-                    in ["url", "html_code", "markdown", "mindmap", "mermaid"],
+                    condition_python=lambda ports: ports["render_type"].value in ["url", "html_code", "markdown", "mindmap", "mermaid"],
                 ),
                 "height": InputPort(
                     name="height",
                     port_type=PortType.NUMBER,
                     value=800,
                     condition="return ['url', 'html_code', 'markdown', 'mindmap', 'mermaid'].includes(fieldsData.render_type.value)",
-                    condition_python=lambda ports: ports["render_type"].value
-                    in ["url", "html_code", "markdown", "mindmap", "mermaid"],
+                    condition_python=lambda ports: ports["render_type"].value in ["url", "html_code", "markdown", "mindmap", "mermaid"],
                 ),
                 "base64_encode": InputPort(
                     name="base64_encode",

{vectorvein-0.2.96 → vectorvein-0.2.98}/src/vectorvein/workflow/nodes/tools.py

@@ -161,11 +161,30 @@ class TextSearch(Node):
                     options=[
                         {"value": "bing", "label": "bing"},
                         {"value": "bochaai", "label": "bochaai"},
+                        {"value": "exa.ai", "label": "exa.ai"},
                         {"value": "jina.ai", "label": "jina.ai"},
                         {"value": "zhipuai", "label": "zhipuai"},
                         {"value": "duckduckgo", "label": "duckduckgo"},
                     ],
                 ),
+                "result_category": InputPort(
+                    name="result_category",
+                    port_type=PortType.SELECT,
+                    value="all",
+                    options=[
+                        {"value": "all", "label": "all"},
+                        {"value": "company", "label": "company"},
+                        {"value": "research_paper", "label": "research_paper"},
+                        {"value": "news", "label": "news"},
+                        {"value": "pdf", "label": "pdf"},
+                        {"value": "github", "label": "github"},
+                        {"value": "personal_site", "label": "personal_site"},
+                        {"value": "linkedin_profile", "label": "linkedin_profile"},
+                        {"value": "financial_report", "label": "financial_report"},
+                    ],
+                    condition="return fieldsData.search_engine.value === 'exa.ai'",
+                    condition_python=lambda ports: ports["search_engine"].value == "exa.ai",
+                ),
                 "count": InputPort(
                     name="count",
                     port_type=PortType.NUMBER,
@@ -219,14 +238,26 @@ class TextSearch(Node):
                 "output_page_title": OutputPort(
                     name="output_page_title",
                     port_type=PortType.LIST,
+                    condition="!fieldsData.combine_result_in_text.value",
+                    condition_python=lambda ports: not ports["combine_result_in_text"].value,
                 ),
                 "output_page_url": OutputPort(
                     name="output_page_url",
                     port_type=PortType.LIST,
+                    condition="!fieldsData.combine_result_in_text.value",
+                    condition_python=lambda ports: not ports["combine_result_in_text"].value,
                 ),
                 "output_page_snippet": OutputPort(
                     name="output_page_snippet",
                     port_type=PortType.LIST,
+                    condition="!fieldsData.combine_result_in_text.value",
+                    condition_python=lambda ports: not ports["combine_result_in_text"].value,
+                ),
+                "output_combined": OutputPort(
+                    name="output_combined",
+                    port_type=PortType.LIST,
+                    condition="!fieldsData.combine_result_in_text.value",
+                    condition_python=lambda ports: not ports["combine_result_in_text"].value,
                 ),
             },
         )