botrun-flow-lang 5.12.264__tar.gz → 6.2.61__tar.gz

{botrun_flow_lang-5.12.264 → botrun_flow_lang-6.2.61}/CHANGELOG.md

@@ -1,3 +1,23 @@
+## [6.2.61]
+- 新增 `ChatVertexAIClaude` 自製 LangGraph chat model（`custom_vertex_claude.py`）：
+  - 透過 Vertex AI `rawPredict` REST API 直接呼叫 Claude，取代 `ChatAnthropicVertex`
+  - 支援 tool calling，完整相容 LangGraph react agent
+  - 處理 SystemMessage（含 cache_control）、HumanMessage、AIMessage（含 tool_calls）、ToolMessage 轉換
+  - 自動合併連續同角色訊息（Anthropic API 要求）
+- 移除 `langchain-google-vertexai` 依賴，避免載入 `google-cloud-aiplatform`（約 26 秒），加速啟動
+
+## [6.1.261]
+- 優化 MCP 工具 docstring，避免 LLM 混淆 URL 有效期限：
+  - `create_html_page`：明確標示為 PERMANENT URL that never expires
+  - `generate_tmp_public_url`：改為 temporary URL that may be deleted periodically
+
+## [6.1.72]
+- web_search 如果沒有使用 openrouter 的 api 時，回傳的 usage_metadata model 要加入 perplexity/ 前綴
+
+## [6.1.71]
+- 幾個 mcp 工具加入回傳 llm usage_metadata
+  - web_search、chat_with_pdf、chat_with_imgs、generate_image
+
 ## [5.12.264]
 - 修正 botrun_flow_lang/langgraph_agents/agents/langgraph_react_agent.py
   - from langchain.tools import StructuredTool 改成 from langchain_core.tools import StructuredTool

{botrun_flow_lang-5.12.264 → botrun_flow_lang-6.2.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: botrun-flow-lang
-Version: 5.12.264
+Version: 6.2.61
 Summary: A flow language for botrun
 Author-email: sebastian-hsu <sebastian.hsu@gmail.com>
 License: MIT
@@ -27,12 +27,11 @@ Requires-Dist: google-cloud-storage<3,>=2.18
 Requires-Dist: google-genai>=1.28.0
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: langchain-anthropic>=0.3.10
-Requires-Dist: langchain-aws>=0.2.17
+Requires-Dist: langchain-aws>=1.0.0
 Requires-Dist: langchain-community>=0.3.27
-Requires-Dist: langchain-core>=0.3.72
+Requires-Dist: langchain-core>=1.1.2
 Requires-Dist: langchain-google-community>=2.0.3
-Requires-Dist: langchain-google-genai>=2.0.9
-Requires-Dist: langchain-google-vertexai<3.0.0,>=2.1.2
+Requires-Dist: langchain-google-genai>=4.0.0
 Requires-Dist: langchain-mcp-adapters>=0.1.7
 Requires-Dist: langchain-openai>=0.3.28
 Requires-Dist: langchain>=0.3.27
@@ -41,7 +40,7 @@ Requires-Dist: langgraph-supervisor>=0.0.20
 Requires-Dist: langgraph>=0.6.3
 Requires-Dist: line-bot-sdk>=3.17.1
 Requires-Dist: mcp<1.11.0,>=1.10.1
-Requires-Dist: numpy<2,>=1
+Requires-Dist: numpy>=1.24.0
 Requires-Dist: openai>=1.99.1
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pdfminer-six==20250506

{botrun_flow_lang-5.12.264 → botrun_flow_lang-6.2.61}/botrun_flow_lang/api/langgraph_api.py

@@ -113,12 +113,17 @@ class GraphSchemaRequest(BaseModel):
     graph_name: str
 
 
-PERPLEXITY_SEARCH_AGENT = "perplexity_search_agent"
+# 從常數檔案匯入，避免外部模組為了取得常數而觸發重型 import
+from botrun_flow_lang.api.langgraph_constants import (
+    LANGGRAPH_REACT_AGENT,
+    GOV_SUBSIDY_AGENT,
+    PERPLEXITY_SEARCH_AGENT,
+)
+
+# 僅在此檔案內部使用的常數
 CUSTOM_WEB_RESEARCH_AGENT = "custom_web_research_agent"
-LANGGRAPH_REACT_AGENT = "langgraph_react_agent"
 DEEP_RESEARCH_AGENT = "deep_research_agent"
 # GOV_RESEARCHER_AGENT = "gov_researcher_agent"
-GOV_SUBSIDY_AGENT = "gov_subsidy_agent"
 GEMINI_SUBSIDY_AGENT = "gemini_subsidy_agent"
 
 

botrun_flow_lang-6.2.61/botrun_flow_lang/api/langgraph_constants.py

@@ -0,0 +1,11 @@
+"""
+LangGraph 常數定義
+
+此檔案只包含常數定義，不包含任何會觸發重型 SDK 載入的 import。
+這樣可以讓其他模組在只需要常數時，不會觸發 langchain_google_vertexai 等重型套件的載入。
+"""
+
+# Graph 名稱常數
+LANGGRAPH_REACT_AGENT = "langgraph_react_agent"
+GOV_SUBSIDY_AGENT = "gov_subsidy_agent"
+PERPLEXITY_SEARCH_AGENT = "perplexity_search_agent"

{botrun_flow_lang-5.12.264 → botrun_flow_lang-6.2.61}/botrun_flow_lang/langgraph_agents/agents/langgraph_react_agent.py

@@ -86,8 +86,11 @@ from langchain_mcp_adapters.client import MultiServerMCPClient
 # ========
 # for Vertex AI
 from google.oauth2 import service_account
-from langchain_google_vertexai import ChatVertexAI
-from langchain_google_vertexai.model_garden import ChatAnthropicVertex
+# 使用自製的 ChatVertexAIClaude 取代 ChatAnthropicVertex，
+# 透過 rawPredict REST API 直接呼叫 Claude，避免載入 google-cloud-aiplatform（約 26 秒）
+from botrun_flow_lang.langgraph_agents.agents.util.custom_vertex_claude import (
+    ChatVertexAIClaude,
+)
 
 load_dotenv()
 
@@ -234,8 +237,10 @@ def get_react_agent_model(model_name: str = ""):
             # 判斷模型類型並創建相應實例
             if vertex_model_name.startswith("gemini-"):
                 # Gemini 系列：gemini-2.5-pro, gemini-2.5-flash, gemini-pro
-                model = ChatVertexAI(
+                # 使用 ChatGoogleGenerativeAI + vertexai=True，避免載入重型的 langchain_google_vertexai
+                model = ChatGoogleGenerativeAI(
                     model=vertex_model_name,
+                    vertexai=True,
                     location=vertex_region,
                     project=vertex_project,
                     credentials=credentials,
@@ -243,21 +248,22 @@ def get_react_agent_model(model_name: str = ""):
                     max_tokens=GEMINI_MAX_TOKENS,
                 )
                 logger.info(
-                    f"model ChatVertexAI {vertex_model_name} @ {vertex_region} (project: {vertex_project})"
+                    f"model ChatGoogleGenerativeAI(vertexai=True) {vertex_model_name} @ {vertex_region} (project: {vertex_project})"
                 )
 
             elif "claude" in vertex_model_name.lower() or vertex_model_name.startswith("maison/"):
                 # Anthropic Claude (model garden)
-                model = ChatAnthropicVertex(
+                # 使用自製的 ChatVertexAIClaude，避免載入 google-cloud-aiplatform
+                model = ChatVertexAIClaude(
                     model=vertex_model_name,
                     location=vertex_region,
-                    project=vertex_project,
+                    project_id=vertex_project,
                     credentials=credentials,
                     temperature=0,
                     max_tokens=ANTHROPIC_MAX_TOKENS,
                 )
                 logger.info(
-                    f"model ChatAnthropicVertex {vertex_model_name} @ {vertex_region} (project: {vertex_project})"
+                    f"model ChatVertexAIClaude {vertex_model_name} @ {vertex_region} (project: {vertex_project})"
                 )
 
             else:
@@ -301,9 +307,9 @@ def get_react_agent_model(model_name: str = ""):
                     "VERTEX_AI_GOOGLE_APPLICATION_CREDENTIALS not set or file not found. Using ADC if available."
                 )
 
-            # 初始化 ChatAnthropicVertex
-            model = ChatAnthropicVertex(
-                project=vertex_project,
+            # 使用自製的 ChatVertexAIClaude，避免載入 google-cloud-aiplatform
+            model = ChatVertexAIClaude(
+                project_id=vertex_project,
                 model=vertex_model,
                 location=vertex_location,
                 credentials=credentials,
@@ -311,7 +317,7 @@ def get_react_agent_model(model_name: str = ""):
                 max_tokens=ANTHROPIC_MAX_TOKENS,
             )
             logger.info(
-                f"model ChatAnthropicVertex {vertex_project} @ {vertex_model} @ {vertex_location}"
+                f"model ChatVertexAIClaude {vertex_project} @ {vertex_model} @ {vertex_location}"
             )
 
         else:

botrun_flow_lang-6.2.61/botrun_flow_lang/langgraph_agents/agents/util/custom_vertex_claude.py

@@ -0,0 +1,406 @@
+"""
+Custom Vertex AI Claude chat model for LangGraph.
+
+Lightweight BaseChatModel that calls Claude via Vertex AI's rawPredict REST API,
+avoiding the heavy google-cloud-aiplatform dependency (~26s import time).
+
+Supports tool calling for LangGraph react agent compatibility.
+"""
+
+import json
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import httpx
+
+from google.auth.transport.requests import Request
+from google.oauth2 import service_account
+from langchain_core.callbacks import CallbackManagerForLLMRun
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+from langchain_core.outputs import ChatGeneration, ChatResult
+from pydantic import ConfigDict
+
+from botrun_flow_lang.utils.botrun_logger import get_default_botrun_logger
+
+logger = get_default_botrun_logger()
+
+
+class ChatVertexAIClaude(BaseChatModel):
+    """
+    Lightweight Vertex AI Claude chat model using rawPredict REST API.
+
+    Replaces ChatAnthropicVertex without importing google-cloud-aiplatform.
+    Supports tool calling for LangGraph react agent.
+
+    Usage:
+        model = ChatVertexAIClaude(
+            model="claude-sonnet-4-5-20250929",
+            project_id="my-project",
+            location="asia-east1",
+            credentials=my_credentials,  # or service_account_file="path/to/sa.json"
+        )
+    """
+
+    model: str = "claude-sonnet-4-5-20250929"
+    max_tokens: int = 64000
+    temperature: float = 0
+    project_id: str = ""
+    location: str = "asia-east1"
+    credentials: Any = None
+    service_account_file: str = ""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @property
+    def _llm_type(self) -> str:
+        return "vertex-ai-claude-custom"
+
+    @property
+    def _identifying_params(self) -> Dict[str, Any]:
+        return {
+            "model": self.model,
+            "max_tokens": self.max_tokens,
+            "temperature": self.temperature,
+            "project_id": self.project_id,
+            "location": self.location,
+        }
+
+    def bind_tools(
+        self,
+        tools: List[Any],
+        *,
+        tool_choice: Optional[Union[str, Dict]] = None,
+        **kwargs,
+    ):
+        """Convert tools to Anthropic format and bind via Runnable.bind()."""
+        formatted_tools = _convert_tools_to_anthropic(tools)
+        bind_kwargs: Dict[str, Any] = {"tools": formatted_tools, **kwargs}
+        if tool_choice is not None:
+            bind_kwargs["tool_choice"] = tool_choice
+        return self.bind(**bind_kwargs)
+
+    def _get_access_token(self) -> str:
+        """Get OAuth2 access token for Vertex AI API."""
+        if self.credentials:
+            creds = self.credentials
+        elif self.service_account_file:
+            creds = service_account.Credentials.from_service_account_file(
+                self.service_account_file,
+                scopes=["https://www.googleapis.com/auth/cloud-platform"],
+            )
+        else:
+            raise ValueError(
+                "ChatVertexAIClaude requires either 'credentials' or 'service_account_file'"
+            )
+
+        if not creds.valid or creds.expired:
+            creds.refresh(Request())
+        return creds.token
+
+    def _convert_messages(
+        self, messages: List[BaseMessage]
+    ) -> Tuple[Union[str, List[Dict]], List[Dict]]:
+        """Convert LangChain messages to Anthropic API format.
+
+        Returns:
+            (system, api_messages) tuple.
+            system: str or list of content blocks (preserves cache_control).
+            api_messages: list of Anthropic-format message dicts.
+        """
+        system_blocks: List[Any] = []
+        raw_messages: List[Dict] = []
+
+        for msg in messages:
+            if isinstance(msg, SystemMessage):
+                if isinstance(msg.content, str):
+                    system_blocks.append({"type": "text", "text": msg.content})
+                elif isinstance(msg.content, list):
+                    for block in msg.content:
+                        if isinstance(block, dict):
+                            system_blocks.append(block)
+                        elif isinstance(block, str):
+                            system_blocks.append({"type": "text", "text": block})
+
+            elif isinstance(msg, HumanMessage):
+                raw_messages.append({"role": "user", "content": msg.content})
+
+            elif isinstance(msg, AIMessage):
+                content_blocks = []
+                if msg.content:
+                    if isinstance(msg.content, str):
+                        content_blocks.append(
+                            {"type": "text", "text": msg.content}
+                        )
+                    elif isinstance(msg.content, list):
+                        for block in msg.content:
+                            if isinstance(block, str):
+                                content_blocks.append(
+                                    {"type": "text", "text": block}
+                                )
+                            elif isinstance(block, dict):
+                                content_blocks.append(block)
+                for tc in msg.tool_calls or []:
+                    content_blocks.append(
+                        {
+                            "type": "tool_use",
+                            "id": tc["id"],
+                            "name": tc["name"],
+                            "input": tc["args"],
+                        }
+                    )
+                raw_messages.append(
+                    {
+                        "role": "assistant",
+                        "content": content_blocks if content_blocks else "",
+                    }
+                )
+
+            elif isinstance(msg, ToolMessage):
+                tool_content = msg.content
+                if not isinstance(tool_content, str):
+                    tool_content = json.dumps(tool_content, ensure_ascii=False)
+                raw_messages.append(
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "tool_result",
+                                "tool_use_id": msg.tool_call_id,
+                                "content": tool_content,
+                            }
+                        ],
+                    }
+                )
+
+        merged = _merge_consecutive_messages(raw_messages)
+
+        # Return system as string (simple) or list (structured with cache_control)
+        has_cache_control = any(
+            isinstance(b, dict) and "cache_control" in b for b in system_blocks
+        )
+        if len(system_blocks) == 1 and not has_cache_control:
+            system: Union[str, List[Dict]] = system_blocks[0].get("text", "")
+        elif system_blocks:
+            system = system_blocks
+        else:
+            system = ""
+
+        return system, merged
+
+    def _generate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs,
+    ) -> ChatResult:
+        """Call Vertex AI Claude via rawPredict (non-streaming)."""
+        system, api_messages = self._convert_messages(messages)
+        access_token = self._get_access_token()
+
+        url = (
+            f"https://{self.location}-aiplatform.googleapis.com/v1/"
+            f"projects/{self.project_id}/locations/{self.location}/"
+            f"publishers/anthropic/models/{self.model}:rawPredict"
+        )
+
+        payload: Dict[str, Any] = {
+            "anthropic_version": "vertex-2023-10-16",
+            "messages": api_messages,
+            "max_tokens": self.max_tokens,
+            "temperature": self.temperature,
+        }
+        if system:
+            payload["system"] = system
+        if stop:
+            payload["stop_sequences"] = stop
+
+        # Tools from bind_tools()
+        tools = kwargs.get("tools", [])
+        if tools:
+            payload["tools"] = tools
+
+        # Tool choice
+        tool_choice = kwargs.get("tool_choice")
+        if tool_choice:
+            if isinstance(tool_choice, str):
+                if tool_choice == "auto":
+                    payload["tool_choice"] = {"type": "auto"}
+                elif tool_choice == "any":
+                    payload["tool_choice"] = {"type": "any"}
+                elif tool_choice == "none":
+                    payload.pop("tools", None)
+                else:
+                    payload["tool_choice"] = {
+                        "type": "tool",
+                        "name": tool_choice,
+                    }
+            elif isinstance(tool_choice, dict):
+                payload["tool_choice"] = tool_choice
+
+        logger.info(
+            f"[ChatVertexAIClaude] rawPredict: model={self.model}, "
+            f"location={self.location}, messages={len(api_messages)}, "
+            f"tools={len(tools)}"
+        )
+
+        # Make API call via httpx
+        data = _http_post_json(url, payload, access_token)
+
+        # Parse response
+        text_parts = []
+        tool_calls = []
+        for block in data.get("content", []):
+            block_type = block.get("type", "")
+            if block_type == "text":
+                text_parts.append(block.get("text", ""))
+            elif block_type == "tool_use":
+                tool_calls.append(
+                    {
+                        "id": block["id"],
+                        "name": block["name"],
+                        "args": block.get("input", {}),
+                    }
+                )
+
+        usage = data.get("usage", {})
+        input_tokens = usage.get("input_tokens", 0)
+        output_tokens = usage.get("output_tokens", 0)
+
+        ai_message = AIMessage(
+            content="".join(text_parts),
+            tool_calls=tool_calls,
+            usage_metadata={
+                "input_tokens": input_tokens,
+                "output_tokens": output_tokens,
+                "total_tokens": input_tokens + output_tokens,
+            },
+            response_metadata={
+                "model": self.model,
+                "stop_reason": data.get("stop_reason", ""),
+            },
+        )
+
+        logger.info(
+            f"[ChatVertexAIClaude] Response: "
+            f"text_len={len(ai_message.content)}, "
+            f"tool_calls={len(tool_calls)}, "
+            f"tokens=({input_tokens}+{output_tokens}={input_tokens + output_tokens})"
+        )
+
+        return ChatResult(
+            generations=[ChatGeneration(message=ai_message)],
+            llm_output={
+                "model": self.model,
+                "usage": {
+                    "input_tokens": input_tokens,
+                    "output_tokens": output_tokens,
+                },
+            },
+        )
+
+
+def _http_post_json(
+    url: str, payload: Dict[str, Any], access_token: str
+) -> Dict[str, Any]:
+    """POST JSON to URL with Bearer auth. Returns parsed JSON response."""
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {access_token}",
+    }
+    try:
+        with httpx.Client(timeout=300.0) as client:
+            response = client.post(url, headers=headers, json=payload)
+            if response.status_code != 200:
+                error_msg = (
+                    f"Vertex AI API error: {response.status_code} - {response.text}"
+                )
+                logger.error(f"[ChatVertexAIClaude] {error_msg}")
+                raise Exception(error_msg)
+            return response.json()
+    except httpx.HTTPStatusError as e:
+        error_body = e.response.text if e.response else ""
+        error_msg = f"Vertex AI API error: {e.response.status_code} - {error_body}"
+        logger.error(f"[ChatVertexAIClaude] {error_msg}")
+        raise Exception(error_msg) from e
+
+
+def _convert_tools_to_anthropic(tools: List[Any]) -> List[Dict]:
+    """Convert LangChain tools to Anthropic tool format."""
+    from langchain_core.utils.function_calling import convert_to_openai_tool
+
+    anthropic_tools = []
+    for tool in tools:
+        if isinstance(tool, dict):
+            if "input_schema" in tool:
+                anthropic_tools.append(tool)
+            elif "function" in tool:
+                func = tool["function"]
+                anthropic_tools.append(
+                    {
+                        "name": func["name"],
+                        "description": func.get("description", ""),
+                        "input_schema": func.get(
+                            "parameters",
+                            {"type": "object", "properties": {}},
+                        ),
+                    }
+                )
+            else:
+                anthropic_tools.append(tool)
+        else:
+            try:
+                oai_tool = convert_to_openai_tool(tool)
+                func = oai_tool["function"]
+                anthropic_tools.append(
+                    {
+                        "name": func["name"],
+                        "description": func.get("description", ""),
+                        "input_schema": func.get(
+                            "parameters",
+                            {"type": "object", "properties": {}},
+                        ),
+                    }
+                )
+            except Exception as e:
+                logger.warning(
+                    f"[ChatVertexAIClaude] Failed to convert tool "
+                    f"{getattr(tool, 'name', tool)}: {e}"
+                )
+
+    return anthropic_tools
+
+
+def _merge_consecutive_messages(messages: List[Dict]) -> List[Dict]:
+    """Merge consecutive messages with the same role (required by Anthropic API)."""
+    if not messages:
+        return []
+
+    merged: List[Dict] = []
+    for msg in messages:
+        if merged and merged[-1]["role"] == msg["role"]:
+            prev_content = merged[-1]["content"]
+            curr_content = msg["content"]
+
+            # Normalize to list of content blocks
+            if isinstance(prev_content, str):
+                prev_content = [{"type": "text", "text": prev_content}]
+            elif not isinstance(prev_content, list):
+                prev_content = [prev_content]
+
+            if isinstance(curr_content, str):
+                curr_content = [{"type": "text", "text": curr_content}]
+            elif not isinstance(curr_content, list):
+                curr_content = [curr_content]
+
+            merged[-1]["content"] = prev_content + curr_content
+        else:
+            merged.append(msg)
+
+    return merged