vectorvein 0.2.24__tar.gz → 0.2.26__tar.gz

{vectorvein-0.2.24 → vectorvein-0.2.26}/PKG-INFO

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

{vectorvein-0.2.24 → vectorvein-0.2.26}/pyproject.toml

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

{vectorvein-0.2.24 → vectorvein-0.2.26}/src/vectorvein/chat_clients/anthropic_client.py

@@ -35,6 +35,7 @@ from anthropic import (
     AsyncAnthropicBedrock,
 )
 from anthropic._types import NOT_GIVEN
+from anthropic._exceptions import APIStatusError as AnthropicAPIStatusError
 from anthropic.types import (
     TextBlock,
     ThinkingBlock,
@@ -52,6 +53,7 @@ from ..types import defaults as defs
 from .utils import cutoff_messages, get_message_token_counts
 from .base_client import BaseChatClient, BaseAsyncChatClient
 from .openai_compatible_client import OpenAICompatibleChatClient, AsyncOpenAICompatibleChatClient
+from ..types.exception import APIStatusError
 from ..types.enums import ContextLengthControlType, BackendType
 from ..types.llm_parameters import (
     Usage,
@@ -601,18 +603,21 @@ class AnthropicChatClient(BaseChatClient):
         self._acquire_rate_limit(self.endpoint, self.model, messages)
 
         if self.stream:
-            stream_response = raw_client.messages.create(
-                model=self.model_id,
-                messages=messages,
-                system=system_prompt,
-                stream=True,
-                temperature=self.temperature,
-                max_tokens=max_tokens,
-                tools=tools_params,
-                tool_choice=tool_choice_param,
-                top_p=top_p,
-                thinking=thinking,
-            )
+            try:
+                stream_response = raw_client.messages.create(
+                    model=self.model_id,
+                    messages=messages,
+                    system=system_prompt,
+                    stream=True,
+                    temperature=self.temperature,
+                    max_tokens=max_tokens,
+                    tools=tools_params,
+                    tool_choice=tool_choice_param,
+                    top_p=top_p,
+                    thinking=thinking,
+                )
+            except AnthropicAPIStatusError as e:
+                raise APIStatusError(message=e.message, response=e.response, body=e.body)
 
             def generator():
                 result = {"content": "", "reasoning_content": "", "usage": {}, "tool_calls": []}
@@ -675,18 +680,21 @@ class AnthropicChatClient(BaseChatClient):
 
             return generator()
         else:
-            response = raw_client.messages.create(
-                model=self.model_id,
-                messages=messages,
-                system=system_prompt,
-                stream=False,
-                temperature=self.temperature,
-                max_tokens=max_tokens,
-                tools=tools_params,
-                tool_choice=tool_choice_param,
-                top_p=top_p,
-                thinking=thinking,
-            )
+            try:
+                response = raw_client.messages.create(
+                    model=self.model_id,
+                    messages=messages,
+                    system=system_prompt,
+                    stream=False,
+                    temperature=self.temperature,
+                    max_tokens=max_tokens,
+                    tools=tools_params,
+                    tool_choice=tool_choice_param,
+                    top_p=top_p,
+                    thinking=thinking,
+                )
+            except AnthropicAPIStatusError as e:
+                raise APIStatusError(message=e.message, response=e.response, body=e.body)
 
             result = {
                 "content": "",
@@ -1140,18 +1148,21 @@ class AsyncAnthropicChatClient(BaseAsyncChatClient):
         await self._acquire_rate_limit(self.endpoint, self.model, messages)
 
         if self.stream:
-            stream_response = await raw_client.messages.create(
-                model=self.model_id,
-                messages=messages,
-                system=system_prompt,
-                stream=True,
-                temperature=self.temperature,
-                max_tokens=max_tokens,
-                tools=tools_params,
-                tool_choice=tool_choice_param,
-                top_p=top_p,
-                thinking=thinking,
-            )
+            try:
+                stream_response = await raw_client.messages.create(
+                    model=self.model_id,
+                    messages=messages,
+                    system=system_prompt,
+                    stream=True,
+                    temperature=self.temperature,
+                    max_tokens=max_tokens,
+                    tools=tools_params,
+                    tool_choice=tool_choice_param,
+                    top_p=top_p,
+                    thinking=thinking,
+                )
+            except AnthropicAPIStatusError as e:
+                raise APIStatusError(message=e.message, response=e.response, body=e.body)
 
             async def generator():
                 result = {"content": "", "reasoning_content": "", "usage": {}, "tool_calls": []}
@@ -1214,18 +1225,21 @@ class AsyncAnthropicChatClient(BaseAsyncChatClient):
 
             return generator()
         else:
-            response = await raw_client.messages.create(
-                model=self.model_id,
-                messages=messages,
-                system=system_prompt,
-                stream=False,
-                temperature=self.temperature,
-                max_tokens=max_tokens,
-                tools=tools_params,
-                tool_choice=tool_choice_param,
-                top_p=top_p,
-                thinking=thinking,
-            )
+            try:
+                response = await raw_client.messages.create(
+                    model=self.model_id,
+                    messages=messages,
+                    system=system_prompt,
+                    stream=False,
+                    temperature=self.temperature,
+                    max_tokens=max_tokens,
+                    tools=tools_params,
+                    tool_choice=tool_choice_param,
+                    top_p=top_p,
+                    thinking=thinking,
+                )
+            except AnthropicAPIStatusError as e:
+                raise APIStatusError(message=e.message, response=e.response, body=e.body)
 
             result = {
                 "content": "",

{vectorvein-0.2.24 → vectorvein-0.2.26}/src/vectorvein/workflow/graph/edge.py

@@ -6,17 +6,17 @@ class Edge:
         self,
         id: str,
         source: str,
-        sourceHandle: str,
+        source_handle: str,
         target: str,
-        targetHandle: str,
+        target_handle: str,
         animated: bool = True,
         type: str = "default",
     ) -> None:
         self.id: str = id
         self.source: str = source
-        self.sourceHandle: str = sourceHandle
+        self.source_handle: str = source_handle
         self.target: str = target
-        self.targetHandle: str = targetHandle
+        self.target_handle: str = target_handle
         self.animated: bool = animated
         self.type: str = type
         self.style: Dict[str, Union[str, int]] = {"stroke": "#28c5e5", "strokeWidth": 3}
@@ -25,9 +25,9 @@ class Edge:
         return {
             "id": self.id,
             "source": self.source,
-            "sourceHandle": self.sourceHandle,
+            "sourceHandle": self.source_handle,
             "target": self.target,
-            "targetHandle": self.targetHandle,
+            "targetHandle": self.target_handle,
             "animated": self.animated,
             "type": self.type,
             "style": self.style,

vectorvein-0.2.26/src/vectorvein/workflow/graph/workflow.py

@@ -0,0 +1,224 @@
+import json
+from typing import List, Union, TypedDict
+
+from .node import Node
+from .edge import Edge
+
+
+class WorkflowCheckResult(TypedDict):
+    """工作流检查结果类型。"""
+
+    no_cycle: bool  # 工作流是否不包含环
+    no_isolated_nodes: bool  # 工作流是否不包含孤立节点
+
+
+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,
+    ):
+        # 获取源节点ID
+        if isinstance(source_node, Node):
+            source_node_id = source_node.id
+        else:
+            source_node_id = source_node
+
+        # 获取目标节点ID
+        if isinstance(target_node, Node):
+            target_node_id = target_node.id
+        else:
+            target_node_id = target_node
+
+        # 检查源节点是否存在
+        source_node_exists = any(node.id == source_node_id for node in self.nodes)
+        if not source_node_exists:
+            raise ValueError(f"源节点不存在: {source_node_id}")
+
+        # 检查目标节点是否存在
+        target_node_exists = any(node.id == target_node_id for node in self.nodes)
+        if not target_node_exists:
+            raise ValueError(f"目标节点不存在: {target_node_id}")
+
+        # 检查源节点的端口是否存在
+        source_node_obj = next(node for node in self.nodes if node.id == source_node_id)
+        if not source_node_obj.has_output_port(source_port):
+            raise ValueError(f"源节点 {source_node_id} 不存在输出端口: {source_port}")
+
+        # 检查目标节点的端口是否存在
+        target_node_obj = next(node for node in self.nodes if node.id == target_node_id)
+        if not target_node_obj.has_input_port(target_port):
+            raise ValueError(f"目标节点 {target_node_id} 不存在输入端口: {target_port}")
+
+        # 检查目标端口是否已有被连接的线
+        for edge in self.edges:
+            if edge.target == target_node_id and edge.target_handle == target_port:
+                raise ValueError(
+                    f"目标节点 {target_node_id} 的输入端口 {target_port} 已经被连接: {edge.source}({edge.source_handle}) → {edge.target}({edge.target_handle})"
+                )
+
+        # 创建并添加边
+        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.source_handle} → {edge.target_handle}"
+            lines.append(f"    {source_label} -->|{label}| {target_label}")
+
+        return "\n".join(lines)
+
+    def _check_dag(self) -> WorkflowCheckResult:
+        """检查流程图是否为有向无环图，并检测是否存在孤立节点。
+
+        Returns:
+            WorkflowCheckResult: 包含检查结果的字典
+                - no_cycle (bool): 如果流程图是有向无环图返回 True，否则返回 False
+                - no_isolated_nodes (bool): 如果不存在孤立节点返回 True，否则返回 False
+        """
+        result: WorkflowCheckResult = {"no_cycle": True, "no_isolated_nodes": True}
+
+        # 过滤掉触发器节点和辅助节点
+        trigger_nodes = [
+            node.id
+            for node in self.nodes
+            if hasattr(node, "category") and (node.category == "triggers" or node.category == "assistedNodes")
+        ]
+
+        # 获取需要检查的节点和边
+        regular_nodes = [node.id for node in self.nodes if node.id not in trigger_nodes]
+        regular_edges = [
+            edge for edge in self.edges if edge.source not in trigger_nodes and edge.target not in trigger_nodes
+        ]
+
+        # ---------- 检查有向图是否有环 ----------
+        # 构建邻接表
+        adjacency = {node_id: [] for node_id in regular_nodes}
+        for edge in regular_edges:
+            if edge.source in adjacency:  # 确保节点在字典中
+                adjacency[edge.source].append(edge.target)
+
+        # 三种状态: 0 = 未访问, 1 = 正在访问, 2 = 已访问完成
+        visited = {node_id: 0 for node_id in regular_nodes}
+
+        def dfs_cycle_detection(node_id):
+            # 如果节点正在被访问，说明找到了环
+            if visited[node_id] == 1:
+                return False
+
+            # 如果节点已经访问完成，无需再次访问
+            if visited[node_id] == 2:
+                return True
+
+            # 标记为正在访问
+            visited[node_id] = 1
+
+            # 访问所有邻居
+            for neighbor in adjacency[node_id]:
+                if neighbor in visited and not dfs_cycle_detection(neighbor):
+                    return False
+
+            # 标记为已访问完成
+            visited[node_id] = 2
+            return True
+
+        # 对每个未访问的节点进行 DFS 检测环
+        for node_id in regular_nodes:
+            if visited[node_id] == 0:
+                if not dfs_cycle_detection(node_id):
+                    result["no_cycle"] = False
+                    break
+
+        # ---------- 检查是否存在孤立节点 ----------
+        # 构建无向图邻接表
+        undirected_adjacency = {node_id: [] for node_id in regular_nodes}
+        for edge in regular_edges:
+            if edge.source in undirected_adjacency and edge.target in undirected_adjacency:
+                undirected_adjacency[edge.source].append(edge.target)
+                undirected_adjacency[edge.target].append(edge.source)
+
+        # 深度优先搜索来检测连通分量
+        undirected_visited = set()
+
+        def dfs_connected_components(node_id):
+            undirected_visited.add(node_id)
+            for neighbor in undirected_adjacency[node_id]:
+                if neighbor not in undirected_visited:
+                    dfs_connected_components(neighbor)
+
+        # 计算连通分量数量
+        connected_components_count = 0
+        for node_id in regular_nodes:
+            if node_id not in undirected_visited:
+                connected_components_count += 1
+                dfs_connected_components(node_id)
+
+        # 如果连通分量数量大于1，说明存在孤立节点
+        if connected_components_count > 1 and len(regular_nodes) > 0:
+            result["no_isolated_nodes"] = False
+
+        return result
+
+    def check(self) -> WorkflowCheckResult:
+        """检查流程图的有效性。
+
+        Returns:
+            WorkflowCheckResult: 包含各种检查结果的字典
+        """
+        return self._check_dag()

{vectorvein-0.2.24 → vectorvein-0.2.26}/src/vectorvein/workflow/nodes/llms.py

@@ -292,6 +292,8 @@ class Claude(Node):
                     port_type=PortType.SELECT,
                     value="claude-3-5-haiku",
                     options=[
+                        {"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-5-haiku", "label": "claude-3-5-haiku"},
                         {"value": "claude-3-opus", "label": "claude-3-opus"},
@@ -338,8 +340,8 @@ class Deepseek(Node):
                     value="deepseek-chat",
                     options=[
                         {"value": "deepseek-chat", "label": "deepseek-chat"},
-                        {"value": "deepseek-reasoner", "label": "deepseek-reasoner"},
-                        {"value": "deepseek-32k", "label": "deepseek-32k"},
+                        {"value": "deepseek-reasoner", "label": "deepseek-r1"},
+                        {"value": "deepseek-r1-distill-qwen-32b", "label": "deepseek-r1-distill-qwen-32b"},
                     ],
                 ),
                 "temperature": InputPort(
@@ -523,12 +525,10 @@ class LingYiWanWu(Node):
                     port_type=PortType.SELECT,
                     value="yi-lightning",
                     options=[
-                        {"value": "yi-lightning", "label": "yi-lightning"},
-                        {"value": "yi-large", "label": "yi-large"},
-                        {"value": "yi-large-turbo", "label": "yi-large-turbo"},
-                        {"value": "yi-medium", "label": "yi-medium"},
-                        {"value": "yi-medium-200k", "label": "yi-medium-200k"},
-                        {"value": "yi-spark", "label": "yi-spark"},
+                        {
+                            "value": "yi-lightning",
+                            "label": "yi-lightning",
+                        },
                     ],
                 ),
                 "temperature": InputPort(
@@ -746,6 +746,7 @@ class OpenAI(Node):
                         {"value": "gpt-4o-mini", "label": "gpt-4o-mini"},
                         {"value": "o1-mini", "label": "o1-mini"},
                         {"value": "o1-preview", "label": "o1-preview"},
+                        {"value": "o3-mini", "label": "o3-mini"},
                     ],
                 ),
                 "temperature": InputPort(
@@ -893,3 +894,91 @@ class XAi(Node):
                 ),
             },
         )
+
+
+class CustomModel(Node):
+    def __init__(self, id: Optional[str] = None):
+        super().__init__(
+            node_type="CustomModel",
+            category="llms",
+            task_name="llms.custom_model",
+            node_id=id,
+            ports={
+                "prompt": InputPort(
+                    name="prompt",
+                    port_type=PortType.TEXTAREA,
+                    value="",
+                ),
+                "model_family": InputPort(
+                    name="model_family",
+                    port_type=PortType.SELECT,
+                    value="",
+                    options=[],
+                ),
+                "llm_model": InputPort(
+                    name="llm_model",
+                    port_type=PortType.SELECT,
+                    value="",
+                    options=[],
+                ),
+                "temperature": InputPort(
+                    name="temperature",
+                    port_type=PortType.TEMPERATURE,
+                    value=0.7,
+                ),
+                "top_p": InputPort(
+                    name="top_p",
+                    port_type=PortType.NUMBER,
+                    value=0.95,
+                ),
+                "stream": InputPort(
+                    name="stream",
+                    port_type=PortType.CHECKBOX,
+                    value=False,
+                ),
+                "system_prompt": InputPort(
+                    name="system_prompt",
+                    port_type=PortType.TEXTAREA,
+                    value="",
+                ),
+                "response_format": InputPort(
+                    name="response_format",
+                    port_type=PortType.SELECT,
+                    value="text",
+                    options=[
+                        {"value": "text", "label": "Text"},
+                        {"value": "json_object", "label": "JSON"},
+                    ],
+                ),
+                "use_function_call": InputPort(
+                    name="use_function_call",
+                    port_type=PortType.CHECKBOX,
+                    value=False,
+                ),
+                "functions": InputPort(
+                    name="functions",
+                    port_type=PortType.SELECT,
+                    value=[],
+                ),
+                "function_call_mode": InputPort(
+                    name="function_call_mode",
+                    port_type=PortType.SELECT,
+                    value="auto",
+                    options=[
+                        {"value": "auto", "label": "auto"},
+                        {"value": "none", "label": "none"},
+                    ],
+                ),
+                "output": OutputPort(
+                    name="output",
+                ),
+                "function_call_output": OutputPort(
+                    name="function_call_output",
+                    condition="return fieldsData.use_function_call.value",
+                ),
+                "function_call_arguments": OutputPort(
+                    name="function_call_arguments",
+                    condition="return fieldsData.use_function_call.value",
+                ),
+            },
+        )

vectorvein-0.2.24/src/vectorvein/workflow/graph/workflow.py

@@ -1,111 +0,0 @@
-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,
-    ):
-        # 获取源节点ID
-        if isinstance(source_node, Node):
-            source_node_id = source_node.id
-        else:
-            source_node_id = source_node
-
-        # 获取目标节点ID
-        if isinstance(target_node, Node):
-            target_node_id = target_node.id
-        else:
-            target_node_id = target_node
-
-        # 检查源节点是否存在
-        source_node_exists = any(node.id == source_node_id for node in self.nodes)
-        if not source_node_exists:
-            raise ValueError(f"源节点不存在: {source_node_id}")
-
-        # 检查目标节点是否存在
-        target_node_exists = any(node.id == target_node_id for node in self.nodes)
-        if not target_node_exists:
-            raise ValueError(f"目标节点不存在: {target_node_id}")
-
-        # 检查源节点的端口是否存在
-        source_node_obj = next(node for node in self.nodes if node.id == source_node_id)
-        if not source_node_obj.has_output_port(source_port):
-            raise ValueError(f"源节点 {source_node_id} 不存在输出端口: {source_port}")
-
-        # 检查目标节点的端口是否存在
-        target_node_obj = next(node for node in self.nodes if node.id == target_node_id)
-        if not target_node_obj.has_input_port(target_port):
-            raise ValueError(f"目标节点 {target_node_id} 不存在输入端口: {target_port}")
-
-        # 创建并添加边
-        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)