vectorvein 0.1.80__py3-none-any.whl → 0.1.82__py3-none-any.whl

vectorvein/chat_clients/openai_compatible_client.py

@@ -3,6 +3,7 @@
 import json
 from functools import cached_property
 from typing import overload, Generator, AsyncGenerator, Any, Literal, Iterable
+import re
 
 import httpx
 from openai import OpenAI, AsyncOpenAI, AzureOpenAI, AsyncAzureOpenAI
@@ -229,6 +230,11 @@ class OpenAICompatibleChatClient(BaseChatClient):
                 full_content = ""
                 result = {}
                 usage = None
+                buffer = ""
+                in_reasoning = False
+                current_reasoning = []
+                current_content = []
+
                 for chunk in stream_response:
                     if chunk.usage and chunk.usage.total_tokens:
                         usage = Usage(
@@ -239,14 +245,11 @@ class OpenAICompatibleChatClient(BaseChatClient):
                             completion_tokens_details=chunk.usage.completion_tokens_details,
                         )
 
-                    if len(chunk.choices) == 0:
-                        if usage:
-                            yield ChatCompletionDeltaMessage(usage=usage)
-                        continue
-                    if not chunk.choices[0].delta:
+                    if len(chunk.choices) == 0 or not chunk.choices[0].delta:
                         if usage:
                             yield ChatCompletionDeltaMessage(usage=usage)
                         continue
+
                     if self.model_setting.function_call_available:
                         if chunk.choices[0].delta.tool_calls:
                             for index, tool_call in enumerate(chunk.choices[0].delta.tool_calls):
@@ -254,16 +257,61 @@ class OpenAICompatibleChatClient(BaseChatClient):
                         yield ChatCompletionDeltaMessage(**chunk.choices[0].delta.model_dump(), usage=usage)
                     else:
                         message = chunk.choices[0].delta.model_dump()
-                        full_content += message["content"] if message["content"] else ""
+                        delta_content = message.get("content", "")
+                        buffer += delta_content
+
+                        while True:
+                            if not in_reasoning:
+                                start_pos = buffer.find("<think>")
+                                if start_pos != -1:
+                                    current_content.append(buffer[:start_pos])
+                                    buffer = buffer[start_pos + 7 :]
+                                    in_reasoning = True
+                                else:
+                                    current_content.append(buffer)
+                                    buffer = ""
+                                    break
+                            else:
+                                end_pos = buffer.find("</think>")
+                                if end_pos != -1:
+                                    current_reasoning.append(buffer[:end_pos])
+                                    buffer = buffer[end_pos + 8 :]
+                                    in_reasoning = False
+                                else:
+                                    current_reasoning.append(buffer)
+                                    buffer = ""
+                                    break
+
+                        message["content"] = "".join(current_content).strip()
+                        if current_reasoning:
+                            message["reasoning_content"] = "".join(current_reasoning).strip()
+                        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 buffer:
+                    if in_reasoning:
+                        current_reasoning.append(buffer)
+                    else:
+                        current_content.append(buffer)
+                    final_message = {
+                        "content": "".join(current_content).strip(),
+                        "reasoning_content": "".join(current_reasoning).strip() if current_reasoning else None,
+                    }
+                    yield ChatCompletionDeltaMessage(**final_message, usage=usage)
+
                 if result:
                     yield ChatCompletionDeltaMessage(**result, usage=usage)
 
@@ -286,6 +334,13 @@ class OpenAICompatibleChatClient(BaseChatClient):
                 "reasoning_content": getattr(response.choices[0].message, "reasoning_content", None),
                 "usage": response.usage.model_dump() if response.usage else None,
             }
+
+            if not result["reasoning_content"] and result["content"]:
+                think_match = re.search(r"<think>(.*?)</think>", result["content"], re.DOTALL)
+                if think_match:
+                    result["reasoning_content"] = think_match.group(1).strip()
+                    result["content"] = result["content"].replace(think_match.group(0), "", 1).strip()
+
             if tools:
                 if self.model_setting.function_call_available and response.choices[0].message.tool_calls:
                     result["tool_calls"] = [
@@ -501,6 +556,11 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
                 full_content = ""
                 result = {}
                 usage = None
+                buffer = ""
+                in_reasoning = False
+                current_reasoning = []
+                current_content = []
+
                 async for chunk in stream_response:
                     if chunk.usage and chunk.usage.total_tokens:
                         usage = Usage(
@@ -511,11 +571,7 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
                             prompt_tokens_details=chunk.usage.prompt_tokens_details,
                         )
 
-                    if len(chunk.choices) == 0:
-                        if usage:
-                            yield ChatCompletionDeltaMessage(usage=usage)
-                        continue
-                    if not chunk.choices[0].delta:
+                    if len(chunk.choices) == 0 or not chunk.choices[0].delta:
                         if usage:
                             yield ChatCompletionDeltaMessage(usage=usage)
                         continue
@@ -527,16 +583,61 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
                         yield ChatCompletionDeltaMessage(**chunk.choices[0].delta.model_dump(), usage=usage)
                     else:
                         message = chunk.choices[0].delta.model_dump()
-                        full_content += message["content"] if message["content"] else ""
+                        delta_content = message.get("content", "")
+                        buffer += delta_content
+
+                        while True:
+                            if not in_reasoning:
+                                start_pos = buffer.find("<think>")
+                                if start_pos != -1:
+                                    current_content.append(buffer[:start_pos])
+                                    buffer = buffer[start_pos + 7 :]
+                                    in_reasoning = True
+                                else:
+                                    current_content.append(buffer)
+                                    buffer = ""
+                                    break
+                            else:
+                                end_pos = buffer.find("</think>")
+                                if end_pos != -1:
+                                    current_reasoning.append(buffer[:end_pos])
+                                    buffer = buffer[end_pos + 8 :]
+                                    in_reasoning = False
+                                else:
+                                    current_reasoning.append(buffer)
+                                    buffer = ""
+                                    break
+
+                        message["content"] = "".join(current_content).strip()
+                        if current_reasoning:
+                            message["reasoning_content"] = "".join(current_reasoning).strip()
+                        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 buffer:
+                    if in_reasoning:
+                        current_reasoning.append(buffer)
+                    else:
+                        current_content.append(buffer)
+                    final_message = {
+                        "content": "".join(current_content).strip(),
+                        "reasoning_content": "".join(current_reasoning).strip() if current_reasoning else None,
+                    }
+                    yield ChatCompletionDeltaMessage(**final_message, usage=usage)
+
                 if result:
                     yield ChatCompletionDeltaMessage(**result, usage=usage)
 
@@ -558,6 +659,13 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
                 "reasoning_content": getattr(response.choices[0].message, "reasoning_content", None),
                 "usage": response.usage.model_dump() if response.usage else None,
             }
+
+            if not result["reasoning_content"] and result["content"]:
+                think_match = re.search(r"<think>(.*?)</think>", result["content"], re.DOTALL)
+                if think_match:
+                    result["reasoning_content"] = think_match.group(1).strip()
+                    result["content"] = result["content"].replace(think_match.group(0), "", 1).strip()
+
             if tools:
                 if self.model_setting.function_call_available and response.choices[0].message.tool_calls:
                     result["tool_calls"] = [

vectorvein/workflow/graph/edge.py

@@ -0,0 +1,36 @@
+from typing import Dict, Any, Union
+
+
+class Edge:
+    def __init__(
+        self,
+        id: str,
+        source: str,
+        sourceHandle: str,
+        target: str,
+        targetHandle: str,
+        animated: bool = True,
+        type: str = "default",
+    ) -> None:
+        self.id: str = id
+        self.source: str = source
+        self.sourceHandle: str = sourceHandle
+        self.target: str = target
+        self.targetHandle: str = targetHandle
+        self.animated: bool = animated
+        self.type: str = type
+        self.style: Dict[str, Union[str, int]] = {"stroke": "#28c5e5", "strokeWidth": 3}
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "source": self.source,
+            "sourceHandle": self.sourceHandle,
+            "target": self.target,
+            "targetHandle": self.targetHandle,
+            "animated": self.animated,
+            "type": self.type,
+            "style": self.style,
+            "data": {},
+            "label": "",
+        }

vectorvein/workflow/graph/node.py

@@ -0,0 +1,82 @@
+import uuid
+from typing import Dict, Any, Optional, List, Union
+
+from .port import PortType, Port, InputPort, OutputPort
+
+
+class Node:
+    def __init__(
+        self,
+        node_type: str,
+        category: str,
+        task_name: str,
+        description: str = "",
+        ports: Optional[Dict[str, Any]] = None,
+        node_id: Optional[str] = None,
+        position: Optional[Dict[str, float]] = None,
+        seleted_workflow_title: str = "",
+        is_template: bool = False,
+        initialized: bool = False,
+    ) -> None:
+        self.id: str = node_id or str(uuid.uuid4())
+        self.type: str = node_type
+        self.category: str = category
+        self.task_name: str = task_name
+        self.description: str = description
+        self.ports: Dict[str, Port] = ports or {}
+        self.position: Dict[str, float] = position or {"x": 0, "y": 0}
+        self.seleted_workflow_title: str = seleted_workflow_title
+        self.is_template: bool = is_template
+        self.initialized: bool = initialized
+        self.ignored: bool = False
+        self.lock: bool = False
+        self.shadow: bool = False
+
+    def add_port(
+        self,
+        name: str,
+        port_type: Union[PortType, str],
+        show: bool = False,
+        value: Any = None,
+        options: Optional[List[Any]] = None,
+        is_output: bool = False,
+        **kwargs,
+    ):
+        if is_output:
+            self.ports[name] = OutputPort(
+                name=name, port_type=port_type, show=show, value=value, options=options, **kwargs
+            )
+        else:
+            self.ports[name] = InputPort(
+                name=name, port_type=port_type, show=show, value=value, options=options, **kwargs
+            )
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "type": self.type,
+            "data": {
+                "task_name": self.task_name,
+                "has_inputs": self.has_inputs(),
+                "description": self.description,
+                "seleted_workflow_title": self.seleted_workflow_title,
+                "is_template": self.is_template,
+                "template": {
+                    port_name: port.to_dict()
+                    for port_name, port in self.ports.items()
+                    if port_name not in ["debug", "seleted_workflow_title", "is_template"]
+                },
+            },
+            "category": self.category,
+            "position": self.position,
+            "initialized": self.initialized,
+            "ignored": self.ignored,
+            "lock": self.lock,
+            "shadow": self.shadow,
+        }
+
+    def has_inputs(self) -> bool:
+        for port in self.ports.values():
+            if isinstance(port, InputPort):
+                return True
+        return False

vectorvein/workflow/graph/port.py

@@ -0,0 +1,173 @@
+from enum import Enum
+from typing import Optional, Any, Dict, List, Union
+
+
+class PortType(Enum):
+    TEXT = "text"
+    NUMBER = "number"
+    CHECKBOX = "checkbox"
+    SELECT = "select"
+    RADIO = "radio"
+    TEXTAREA = "textarea"
+    INPUT = "input"
+    FILE = "file"
+    LIST = "list"
+    COLOR = "color"
+    TEMPERATURE = "temperature"
+
+
+class Port:
+    def __init__(
+        self,
+        name: str,
+        port_type: Union[PortType, str],
+        required: bool = True,
+        show: bool = False,
+        value: Any = None,
+        options: Optional[List[Any]] = None,
+        field_type: Optional[str] = None,
+        is_output: bool = False,
+        condition: Optional[str] = None,
+        max_length: Optional[int] = None,
+        support_file_types: Optional[List[str]] = None,
+        multiple: Optional[bool] = None,
+        group: Optional[str] = None,
+        group_collpased: bool = False,
+        has_tooltip: bool = False,
+        max: Optional[Union[int, float]] = None,
+        min: Optional[Union[int, float]] = None,
+        max_count: Optional[int] = None,
+        list: bool = False,
+    ) -> None:
+        self.name = name
+        self.port_type = port_type
+        self.required = required
+        self.show = show
+        self.value = value
+        self.options = options
+        self.field_type = field_type
+        self.is_output = is_output
+        self.condition = condition
+        self.max_length = max_length
+        self.support_file_types = support_file_types
+        self.multiple = multiple
+        self.group = group
+        self.group_collpased = group_collpased
+        self.has_tooltip = has_tooltip
+        self.max = max
+        self.min = min
+        self.max_count = max_count
+        self.list = list
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "display_name": self.name,
+            "field_type": self.port_type.value if isinstance(self.port_type, PortType) else self.port_type,
+            "required": self.required,
+            "show": self.show,
+            "value": self.value,
+            "options": self.options,
+            "type": self.field_type,
+            "is_output": self.is_output,
+            # "condition": f"(fieldsData) => {{ {self.condition} }}" if self.condition else "",
+            "max_length": self.max_length,
+            "support_file_types": ", ".join(self.support_file_types) if self.support_file_types else None,
+            "multiple": self.multiple,
+            "group": self.group,
+            "group_collpased": self.group_collpased,
+            "has_tooltip": self.has_tooltip,
+            "max": self.max,
+            "min": self.min,
+            "list": self.list,
+        }
+
+
+class InputPort(Port):
+    def __init__(
+        self,
+        name: str,
+        port_type: Union[PortType, str],
+        required: bool = True,
+        show: bool = False,
+        value: Any = None,
+        options: Optional[List[Any]] = None,
+        field_type: Optional[str] = None,
+        condition: Optional[str] = None,
+        max_length: Optional[int] = None,
+        support_file_types: Optional[List[str]] = None,
+        multiple: Optional[bool] = None,
+        group: Optional[str] = None,
+        group_collpased: bool = False,
+        has_tooltip: bool = False,
+        max: Optional[Union[int, float]] = None,
+        min: Optional[Union[int, float]] = None,
+        max_count: Optional[int] = None,
+        list: bool = False,
+    ) -> None:
+        super().__init__(
+            name=name,
+            port_type=port_type,
+            required=required,
+            show=show,
+            value=value,
+            options=options,
+            field_type=field_type,
+            is_output=False,
+            condition=condition,
+            max_length=max_length,
+            support_file_types=support_file_types,
+            multiple=multiple,
+            group=group,
+            group_collpased=group_collpased,
+            has_tooltip=has_tooltip,
+            max=max,
+            min=min,
+            max_count=max_count,
+            list=list,
+        )
+
+
+class OutputPort(Port):
+    def __init__(
+        self,
+        name: str = "output",
+        port_type: Union[PortType, str] = PortType.TEXT,
+        required: bool = True,
+        show: bool = False,
+        value: Any = None,
+        options: Optional[List[Any]] = None,
+        field_type: Optional[str] = None,
+        condition: Optional[str] = None,
+        max_length: Optional[int] = None,
+        support_file_types: Optional[List[str]] = None,
+        multiple: Optional[bool] = None,
+        group: Optional[str] = None,
+        group_collpased: bool = False,
+        has_tooltip: bool = False,
+        max: Optional[Union[int, float]] = None,
+        min: Optional[Union[int, float]] = None,
+        max_count: Optional[int] = None,
+        list: bool = False,
+    ) -> None:
+        super().__init__(
+            name=name,
+            port_type=port_type,
+            required=required,
+            show=show,
+            value=value,
+            options=options,
+            field_type=field_type,
+            is_output=True,
+            condition=condition,
+            max_length=max_length,
+            support_file_types=support_file_types,
+            multiple=multiple,
+            group=group,
+            group_collpased=group_collpased,
+            has_tooltip=has_tooltip,
+            max=max,
+            min=min,
+            max_count=max_count,
+            list=list,
+        )

vectorvein/workflow/graph/workflow.py

@@ -0,0 +1,87 @@
+import json
+from typing import List, Union
+
+from .node import Node
+from .edge import Edge
+
+
+class Workflow:
+    def __init__(self) -> None:
+        self.nodes: List[Node] = []
+        self.edges: List[Edge] = []
+
+    def add_node(self, node: Node):
+        self.nodes.append(node)
+
+    def add_nodes(self, nodes: List[Node]):
+        self.nodes.extend(nodes)
+
+    def add_edge(self, edge: Edge):
+        self.edges.append(edge)
+
+    def connect(
+        self,
+        source_node: Union[str, Node],
+        source_port: str,
+        target_node: Union[str, Node],
+        target_port: str,
+    ):
+        if isinstance(source_node, Node):
+            source_node_id = source_node.id
+        else:
+            source_node_id = source_node
+        if isinstance(target_node, Node):
+            target_node_id = target_node.id
+        else:
+            target_node_id = target_node
+
+        edge_id = f"vueflow__edge-{source_node_id}{source_port}-{target_node_id}{target_port}"
+        edge = Edge(edge_id, source_node_id, source_port, target_node_id, target_port)
+        self.add_edge(edge)
+
+    def to_dict(self):
+        return {
+            "nodes": [node.to_dict() for node in self.nodes],
+            "edges": [edge.to_dict() for edge in self.edges],
+            "viewport": {"x": 0, "y": 0, "zoom": 1},
+        }
+
+    def to_json(self, ensure_ascii=False):
+        return json.dumps(self.to_dict(), ensure_ascii=ensure_ascii)
+
+    def to_mermaid(self) -> str:
+        """生成 Mermaid 格式的流程图。
+
+        Returns:
+            str: Mermaid 格式的流程图文本
+        """
+        lines = ["flowchart TD"]
+
+        # 创建节点类型到序号的映射
+        type_counters = {}
+        node_id_to_label = {}
+
+        # 首先为所有节点生成标签
+        for node in self.nodes:
+            node_type = node.type.lower()
+            if node_type not in type_counters:
+                type_counters[node_type] = 0
+            node_label = f"{node_type}_{type_counters[node_type]}"
+            node_id_to_label[node.id] = node_label
+            type_counters[node_type] += 1
+
+        # 添加节点定义
+        for node in self.nodes:
+            node_label = node_id_to_label[node.id]
+            lines.append(f'    {node_label}["{node_label} ({node.type})"]')
+
+        lines.append("")  # 添加一个空行分隔节点和边的定义
+
+        # 添加边的定义
+        for edge in self.edges:
+            source_label = node_id_to_label[edge.source]
+            target_label = node_id_to_label[edge.target]
+            label = f"{edge.sourceHandle} → {edge.targetHandle}"
+            lines.append(f"    {source_label} -->|{label}| {target_label}")
+
+        return "\n".join(lines)