botrun-flow-lang 5.12.264__py3-none-any.whl → 6.2.61__py3-none-any.whl

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/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/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/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

botrun_flow_lang/langgraph_agents/agents/util/img_util.py

@@ -4,8 +4,11 @@ import httpx
 import os
 import imghdr
 from pathlib import Path
+from typing import Dict, Any, List, Tuple
 from dotenv import load_dotenv
 
+from botrun_flow_lang.langgraph_agents.agents.util.usage_metadata import UsageMetadata
+
 load_dotenv()
 
 
@@ -50,7 +53,7 @@ def get_img_content_type(file_path: str | Path) -> str:
 
 def analyze_imgs_with_claude(
     img_urls: list[str], user_input: str, model_name: str = "claude-sonnet-4-5-20250929"
-) -> str:
+) -> Tuple[str, UsageMetadata]:
     """
     Analyze multiple images using Claude Vision API
 
@@ -60,7 +63,7 @@ def analyze_imgs_with_claude(
         model_name: Claude model name to use
 
     Returns:
-        str: Claude's analysis of the image content(s) based on the query
+        Tuple[str, UsageMetadata]: Claude's analysis and usage metadata
 
     Raises:
         ValueError: If image URLs are invalid or model parameters are incorrect
@@ -120,10 +123,20 @@ def analyze_imgs_with_claude(
                 ],
             )
 
+            # Extract usage metadata
+            usage = UsageMetadata(
+                prompt_tokens=message.usage.input_tokens,
+                completion_tokens=message.usage.output_tokens,
+                total_tokens=message.usage.input_tokens + message.usage.output_tokens,
+                cache_creation_input_tokens=getattr(message.usage, 'cache_creation_input_tokens', 0) or 0,
+                cache_read_input_tokens=getattr(message.usage, 'cache_read_input_tokens', 0) or 0,
+                model=model_name,
+            )
+
             print(
                 f"analyze_imgs_with_claude============> input_token: {message.usage.input_tokens} output_token: {message.usage.output_tokens}",
             )
-            return message.content[0].text
+            return message.content[0].text, usage
         except anthropic.APIError as e:
             import traceback
 
@@ -144,7 +157,7 @@ def analyze_imgs_with_gemini(
     img_urls: list[str],
     user_input: str,
     model_name: str = "gemini-2.5-flash",
-) -> str:
+) -> Tuple[str, UsageMetadata]:
     """
     Analyze multiple images using Gemini Vision API
 
@@ -154,7 +167,7 @@ def analyze_imgs_with_gemini(
         model_name: Gemini model name to use
 
     Returns:
-        str: Gemini's analysis of the image content(s) based on the query
+        Tuple[str, UsageMetadata]: Gemini's analysis and usage metadata
 
     Raises:
         ValueError: If image URLs are invalid or model parameters are incorrect
@@ -216,10 +229,23 @@ def analyze_imgs_with_gemini(
             contents=contents,
         )
 
-        print(
-            f"analyze_imgs_with_gemini============> input_token: {response.usage_metadata.prompt_token_count} output_token: {response.usage_metadata.candidates_token_count}"
-        )
-        return response.text
+        # Extract usage metadata
+        usage = UsageMetadata(model=model_name)
+        if hasattr(response, "usage_metadata"):
+            usage_meta = response.usage_metadata
+            usage = UsageMetadata(
+                prompt_tokens=getattr(usage_meta, 'prompt_token_count', 0) or 0,
+                completion_tokens=getattr(usage_meta, 'candidates_token_count', 0) or 0,
+                total_tokens=getattr(usage_meta, 'total_token_count', 0) or 0,
+                cache_creation_input_tokens=0,
+                cache_read_input_tokens=getattr(usage_meta, 'cached_content_token_count', 0) or 0,
+                model=model_name,
+            )
+            print(
+                f"analyze_imgs_with_gemini============> input_token: {usage_meta.prompt_token_count} output_token: {usage_meta.candidates_token_count}"
+            )
+
+        return response.text, usage
 
     except httpx.RequestError as e:
         import traceback
@@ -233,7 +259,7 @@ def analyze_imgs_with_gemini(
         raise Exception(f"Error analyzing image(s) with Gemini {model_name}: {str(e)}")
 
 
-def analyze_imgs(img_urls: list[str], user_input: str) -> str:
+def analyze_imgs(img_urls: list[str], user_input: str) -> Dict[str, Any]:
     """
     Analyze multiple images using configured AI models.
 
@@ -248,8 +274,13 @@ def analyze_imgs(img_urls: list[str], user_input: str) -> str:
         user_input: User's query about the image content(s)
 
     Returns:
-        str: AI analysis of the image content(s) based on the query
+        Dict[str, Any]: {
+            "result": str,  # AI analysis result
+            "usage_metadata": List[Dict]  # Token usage for each LLM call
+        }
     """
+    usage_list: List[UsageMetadata] = []
+
     # Get models from environment variable, split by comma if multiple models
     models_str = os.getenv("IMG_ANALYZER_MODEL", "gemini-2.5-flash")
     print(f"[analyze_imgs] 分析IMG使用模型: {models_str}")
@@ -267,12 +298,20 @@ def analyze_imgs(img_urls: list[str], user_input: str) -> str:
         try:
             if model.startswith("gemini-"):
                 print(f"[analyze_imgs] 嘗試使用 Gemini 模型: {model}")
-                result = analyze_imgs_with_gemini(img_urls, user_input, model)
-                return result
+                result, usage = analyze_imgs_with_gemini(img_urls, user_input, model)
+                usage_list.append(usage)
+                return {
+                    "result": result,
+                    "usage_metadata": [u.to_dict() for u in usage_list],
+                }
             elif model.startswith("claude-"):
                 print(f"[analyze_imgs] 嘗試使用 Claude 模型: {model}")
-                result = analyze_imgs_with_claude(img_urls, user_input, model)
-                return result
+                result, usage = analyze_imgs_with_claude(img_urls, user_input, model)
+                usage_list.append(usage)
+                return {
+                    "result": result,
+                    "usage_metadata": [u.to_dict() for u in usage_list],
+                }
             else:
                 print(f"[analyze_imgs] 不支持的模型格式: {model}, 跳過")
                 errors.append(f"不支持的模型格式: {model}")
@@ -291,4 +330,7 @@ def analyze_imgs(img_urls: list[str], user_input: str) -> str:
 
     # If we've tried all models and none succeeded, return all errors
     error_summary = "\n".join(errors)
-    return f"錯誤: 所有配置的模型都失敗了。詳細錯誤：\n{error_summary}"
+    return {
+        "result": f"錯誤: 所有配置的模型都失敗了。詳細錯誤：\n{error_summary}",
+        "usage_metadata": [u.to_dict() for u in usage_list],
+    }