vectorvein 0.3.17__py3-none-any.whl → 0.3.19__py3-none-any.whl

vectorvein/api/__init__.py

@@ -8,6 +8,8 @@ from .models import (
     WorkflowOutput,
     WorkflowRunResult,
     AccessKeyListResponse,
+    Workflow,
+    WorkflowTag,
 )
 from .exceptions import (
     VectorVeinAPIError,
@@ -27,6 +29,8 @@ __all__ = [
     "WorkflowOutput",
     "WorkflowRunResult",
     "AccessKeyListResponse",
+    "Workflow",
+    "WorkflowTag",
     "VectorVeinAPIError",
     "APIKeyError",
     "WorkflowError",

vectorvein/api/client.py

@@ -24,6 +24,8 @@ from .models import (
     WorkflowOutput,
     WorkflowRunResult,
     AccessKeyListResponse,
+    Workflow,
+    WorkflowTag,
 )
 
 
@@ -223,6 +225,71 @@ class VectorVeinClient:
         else:
             raise WorkflowError(f"Workflow execution failed: {response['msg']}")
 
+    def create_workflow(
+        self,
+        title: str = "New workflow",
+        brief: str = "",
+        images: list[str] | None = None,
+        tags: list[dict[str, str]] | None = None,
+        data: dict[str, Any] | None = None,
+        language: str = "zh-CN",
+        tool_call_data: dict[str, Any] | None = None,
+        source_workflow_wid: str | None = None,
+    ) -> Workflow:
+        """Create a new workflow
+
+        Args:
+            title: Workflow title, default is "New workflow"
+            brief: Workflow brief description
+            images: List of image URLs
+            tags: List of workflow tags, each tag should have 'tid' field
+            data: Workflow data containing nodes and edges, default is {"nodes": [], "edges": []}
+            language: Workflow language, default is "zh-CN"
+            tool_call_data: Tool call data
+            source_workflow_wid: Source workflow ID for copying
+
+        Returns:
+            Workflow: Created workflow information
+
+        Raises:
+            VectorVeinAPIError: Workflow creation error
+        """
+        payload = {
+            "title": title,
+            "brief": brief,
+            "images": images or [],
+            "tags": tags or [],
+            "data": data or {"nodes": [], "edges": []},
+            "language": language,
+            "tool_call_data": tool_call_data or {},
+        }
+
+        if source_workflow_wid:
+            payload["source_workflow_wid"] = source_workflow_wid
+
+        response = self._request("POST", "workflow/create", json=payload)
+
+        # Parse tags from response
+        workflow_tags = []
+        if response["data"].get("tags"):
+            for tag_data in response["data"]["tags"]:
+                if isinstance(tag_data, dict):
+                    workflow_tags.append(WorkflowTag(**tag_data))
+
+        return Workflow(
+            wid=response["data"]["wid"],
+            title=response["data"]["title"],
+            brief=response["data"]["brief"],
+            data=response["data"]["data"],
+            language=response["data"]["language"],
+            images=response["data"]["images"],
+            tags=workflow_tags,
+            source_workflow=response["data"].get("source_workflow"),
+            tool_call_data=response["data"].get("tool_call_data"),
+            create_time=response["data"].get("create_time"),
+            update_time=response["data"].get("update_time"),
+        )
+
     def get_access_keys(self, access_keys: list[str] | None = None, get_type: Literal["selected", "all"] = "selected") -> list[AccessKey]:
         """Get access key information
 
@@ -650,6 +717,71 @@ class AsyncVectorVeinClient:
         else:
             raise WorkflowError(f"Workflow execution failed: {response['msg']}")
 
+    async def create_workflow(
+        self,
+        title: str = "New workflow",
+        brief: str = "",
+        images: list[str] | None = None,
+        tags: list[dict[str, str]] | None = None,
+        data: dict[str, Any] | None = None,
+        language: str = "zh-CN",
+        tool_call_data: dict[str, Any] | None = None,
+        source_workflow_wid: str | None = None,
+    ) -> Workflow:
+        """Async create a new workflow
+
+        Args:
+            title: Workflow title, default is "New workflow"
+            brief: Workflow brief description
+            images: List of image URLs
+            tags: List of workflow tags, each tag should have 'tid' field
+            data: Workflow data containing nodes and edges, default is {"nodes": [], "edges": []}
+            language: Workflow language, default is "zh-CN"
+            tool_call_data: Tool call data
+            source_workflow_wid: Source workflow ID for copying
+
+        Returns:
+            Workflow: Created workflow information
+
+        Raises:
+            VectorVeinAPIError: Workflow creation error
+        """
+        payload = {
+            "title": title,
+            "brief": brief,
+            "images": images or [],
+            "tags": tags or [],
+            "data": data or {"nodes": [], "edges": []},
+            "language": language,
+            "tool_call_data": tool_call_data or {},
+        }
+
+        if source_workflow_wid:
+            payload["source_workflow_wid"] = source_workflow_wid
+
+        response = await self._request("POST", "workflow/create", json=payload)
+
+        # Parse tags from response
+        workflow_tags = []
+        if response["data"].get("tags"):
+            for tag_data in response["data"]["tags"]:
+                if isinstance(tag_data, dict):
+                    workflow_tags.append(WorkflowTag(**tag_data))
+
+        return Workflow(
+            wid=response["data"]["wid"],
+            title=response["data"]["title"],
+            brief=response["data"]["brief"],
+            data=response["data"]["data"],
+            language=response["data"]["language"],
+            images=response["data"]["images"],
+            tags=workflow_tags,
+            source_workflow=response["data"].get("source_workflow"),
+            tool_call_data=response["data"].get("tool_call_data"),
+            create_time=response["data"].get("create_time"),
+            update_time=response["data"].get("update_time"),
+        )
+
     async def get_access_keys(self, access_keys: list[str] | None = None, get_type: Literal["selected", "all"] = "selected") -> list[AccessKey]:
         """Async get access key information
 

vectorvein/api/models.py

@@ -72,3 +72,42 @@ class AccessKeyListResponse:
     total: int
     page_size: int
     page: int
+
+
+@dataclass
+class WorkflowTag:
+    """Workflow tag"""
+
+    tid: str
+    name: str
+
+
+@dataclass
+class Workflow:
+    """Workflow information"""
+
+    wid: str
+    title: str
+    brief: str
+    data: dict[str, Any]
+    language: str
+    images: list[str]
+    tags: list[WorkflowTag]
+    source_workflow: str | None = None
+    tool_call_data: dict[str, Any] | None = None
+    create_time: str | None = None
+    update_time: str | None = None
+
+
+@dataclass
+class WorkflowCreateRequest:
+    """Workflow creation request data"""
+
+    title: str = "New workflow"
+    brief: str = ""
+    images: list[str] | None = None
+    tags: list[dict[str, str]] | None = None
+    data: dict[str, Any] | None = None
+    language: str = "zh-CN"
+    tool_call_data: dict[str, Any] | None = None
+    source_workflow_wid: str | None = None

vectorvein/chat_clients/anthropic_client.py

@@ -146,9 +146,10 @@ def refactor_into_openai_messages(messages: Iterable[MessageParam]):
                     _content.append(item.model_dump())
                 elif isinstance(item, ThinkingBlock | RedactedThinkingBlock):
                     continue
-                elif item.get("type") == "image":
-                    image_data = item.get("source", {}).get("data", "")
-                    media_type = item.get("source", {}).get("media_type", "")
+                elif isinstance(item, dict) and item.get("type") == "image":
+                    source = item.get("source", {})
+                    image_data = source.get("data", "") if isinstance(source, dict) else ""
+                    media_type = source.get("media_type", "") if isinstance(source, dict) else ""
                     data_url = f"data:{media_type};base64,{image_data}"
                     _content.append(
                         {

vectorvein/chat_clients/base_client.py

@@ -72,7 +72,9 @@ class BaseChatClient(ABC):
         self.http_client = http_client
 
         if backend_name is not None:
-            self.BACKEND_NAME = BackendType(backend_name)
+            self.backend_name = BackendType(backend_name)  # type: ignore
+        else:
+            self.backend_name = self.BACKEND_NAME
 
         if settings is None:
             self.settings = default_settings
@@ -81,7 +83,7 @@ class BaseChatClient(ABC):
         else:
             self.settings = settings
 
-        self.backend_settings = self.settings.get_backend(self.BACKEND_NAME)
+        self.backend_settings = self.settings.get_backend(self.backend_name)
 
         self.rate_limiter = self._init_rate_limiter()
         self.active_requests = defaultdict(int)
@@ -493,7 +495,9 @@ class BaseAsyncChatClient(ABC):
         self.http_client = http_client
 
         if backend_name is not None:
-            self.BACKEND_NAME = BackendType(backend_name)
+            self.backend_name = BackendType(backend_name)  # type: ignore
+        else:
+            self.backend_name = self.BACKEND_NAME
 
         if settings is None:
             self.settings = default_settings
@@ -502,7 +506,7 @@ class BaseAsyncChatClient(ABC):
         else:
             self.settings = settings
 
-        self.backend_settings = self.settings.get_backend(self.BACKEND_NAME)
+        self.backend_settings = self.settings.get_backend(self.backend_name)
 
         self.rate_limiter = self._init_rate_limiter()
         self.active_requests = defaultdict(int)

vectorvein/chat_clients/openai_compatible_client.py

@@ -46,6 +46,64 @@ if TYPE_CHECKING:
     from ..types.settings import SettingsDict
 
 
+def get_thinking_tags(backend: BackendType) -> tuple[str, str]:
+    """Get the appropriate thinking tags for the given backend.
+
+    Args:
+        backend: The backend type
+
+    Returns:
+        Tuple of (start_tag, end_tag) for thinking content
+    """
+    if backend == BackendType.Gemini:
+        return ("<thought>", "</thought>")
+    else:
+        return ("<think>", "</think>")
+
+
+def process_thinking_content(buffer: str, in_reasoning: bool, start_tag: str, end_tag: str) -> tuple[str, str, str, bool]:
+    """Process buffer content to extract thinking tags.
+
+    Args:
+        buffer: Content buffer to process
+        in_reasoning: Whether currently inside thinking tags
+        start_tag: Opening thinking tag
+        end_tag: Closing thinking tag
+
+    Returns:
+        Tuple of (remaining_buffer, output_content, reasoning_content, new_in_reasoning_state)
+    """
+    current_output_content = ""
+    current_reasoning_content = ""
+
+    while buffer:
+        if not in_reasoning:
+            start_pos = buffer.find(start_tag)
+            if start_pos != -1:
+                # Found start tag
+                if start_pos > 0:
+                    current_output_content += buffer[:start_pos]
+                buffer = buffer[start_pos + len(start_tag) :]
+                in_reasoning = True
+            else:
+                # No start tag found, output all content
+                current_output_content += buffer
+                buffer = ""
+        else:
+            end_pos = buffer.find(end_tag)
+            if end_pos != -1:
+                # Found end tag
+                current_reasoning_content += buffer[:end_pos]
+                buffer = buffer[end_pos + len(end_tag) :]
+                in_reasoning = False
+            else:
+                # No end tag found, accumulate as reasoning content
+                current_reasoning_content += buffer
+                buffer = ""
+
+    return buffer, current_output_content, current_reasoning_content, in_reasoning
+
+
 class OpenAICompatibleChatClient(BaseChatClient):
     DEFAULT_MODEL: str = ""
     BACKEND_NAME: BackendType
@@ -280,6 +338,9 @@ class OpenAICompatibleChatClient(BaseChatClient):
         if self.model_id is None:
             self.model_id = self.model_setting.id
 
+        # Get thinking tags for the current backend
+        start_tag, end_tag = get_thinking_tags(self.backend_name)
+
         if not skip_cutoff and self.context_length_control == ContextLengthControlType.Latest:
             messages = cutoff_messages(
                 messages,
@@ -404,40 +465,14 @@ class OpenAICompatibleChatClient(BaseChatClient):
                                 tool_call.index = index
                                 tool_call.type = "function"  # 也是 MiniMax 的不规范导致的问题
 
-                        # 即使支持 function call，也要处理 <think> 标签
+                        # 即使支持 function call，也要处理思考标签
                         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 = ""
+                            # 处理缓冲区中的内容，提取思考标签
+                            buffer, current_output_content, current_reasoning_content, in_reasoning = process_thinking_content(buffer, in_reasoning, start_tag, end_tag)
 
                             # 累积内容
                             if current_output_content:
@@ -463,34 +498,8 @@ class OpenAICompatibleChatClient(BaseChatClient):
                         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 = ""
+                        # 处理缓冲区中的内容，提取思考标签
+                        buffer, current_output_content, current_reasoning_content, in_reasoning = process_thinking_content(buffer, in_reasoning, start_tag, end_tag)
 
                         # 累积内容
                         if current_output_content:
@@ -597,7 +606,9 @@ class OpenAICompatibleChatClient(BaseChatClient):
             }
 
             if not result["reasoning_content"] and result["content"]:
-                think_match = re.search(r"<think>(.*?)</think>", result["content"], re.DOTALL)
+                # Create dynamic regex pattern based on backend
+                think_pattern = f"{re.escape(start_tag)}(.*?){re.escape(end_tag)}"
+                think_match = re.search(think_pattern, result["content"], re.DOTALL)
                 if think_match:
                     result["reasoning_content"] = think_match.group(1)
                     result["content"] = result["content"].replace(think_match.group(0), "", 1)
@@ -850,6 +861,9 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
         if self.model_id is None:
             self.model_id = self.model_setting.id
 
+        # Get thinking tags for the current backend
+        start_tag, end_tag = get_thinking_tags(self.backend_name)
+
         if not skip_cutoff and self.context_length_control == ContextLengthControlType.Latest:
             messages = cutoff_messages(
                 messages,
@@ -974,40 +988,14 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
                                 tool_call.index = index
                                 tool_call.type = "function"
 
-                        # 即使支持 function call，也要处理 <think> 标签
+                        # 即使支持 function call，也要处理思考标签
                         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 = ""
+                            # 处理缓冲区中的内容，提取思考标签
+                            buffer, current_output_content, current_reasoning_content, in_reasoning = process_thinking_content(buffer, in_reasoning, start_tag, end_tag)
 
                             # 累积内容
                             if current_output_content:
@@ -1033,34 +1021,8 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
                         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 = ""
+                        # 处理缓冲区中的内容，提取思考标签
+                        buffer, current_output_content, current_reasoning_content, in_reasoning = process_thinking_content(buffer, in_reasoning, start_tag, end_tag)
 
                         # 累积内容
                         if current_output_content:
@@ -1167,7 +1129,9 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
             }
 
             if not result["reasoning_content"] and result["content"]:
-                think_match = re.search(r"<think>(.*?)</think>", result["content"], re.DOTALL)
+                # Create dynamic regex pattern based on backend
+                think_pattern = f"{re.escape(start_tag)}(.*?){re.escape(end_tag)}"
+                think_match = re.search(think_pattern, result["content"], re.DOTALL)
                 if think_match:
                     result["reasoning_content"] = think_match.group(1)
                     result["content"] = result["content"].replace(think_match.group(0), "", 1)