botrun-flow-lang 5.11.281__py3-none-any.whl → 5.12.261__py3-none-any.whl

botrun_flow_lang/api/hatch_api.py

@@ -286,13 +286,40 @@ async def get_hatches(
     user_id: str,
     offset: int = Query(0, ge=0),
     limit: int = Query(20, ge=1, le=100),
+    sort_by: str = Query("updated_at", description="Field to sort by (name, updated_at)"),
+    order: str = Query("desc", regex="^(asc|desc)$", description="Sort order: asc or desc"),
     current_user: CurrentUser = Depends(verify_jwt_token),
     hatch_store=Depends(get_hatch_store),
 ):
+    """Get hatches for a user with sorting options.
+
+    Args:
+        user_id: User ID to get hatches for
+        offset: Pagination offset
+        limit: Maximum number of results (1-100)
+        sort_by: Field to sort by - only 'name' or 'updated_at' are supported (default: updated_at)
+        order: Sort order - 'asc' or 'desc' (default: desc for newest first)
+
+    Returns:
+        List of hatches sorted by the specified field
+
+    Raises:
+        HTTPException: 400 if sort_by field is not supported
+    """
     # Verify user permission to access hatches for the specified user_id
     verify_user_permission(current_user, user_id)
 
-    hatches, error = await hatch_store.get_hatches(user_id, offset, limit)
+    # Validate sort_by field - only allow fields with Firestore indexes
+    allowed_sort_fields = ["name", "updated_at"]
+    if sort_by not in allowed_sort_fields:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid sort_by field '{sort_by}'. Allowed fields: {', '.join(allowed_sort_fields)}",
+        )
+
+    hatches, error = await hatch_store.get_hatches(
+        user_id, offset, limit, sort_by, order
+    )
     if error:
         raise HTTPException(status_code=500, detail=error)
     return hatches

botrun_flow_lang/api/line_bot_api.py

@@ -722,10 +722,11 @@ async def subsidy_webhook(request: Request):
                 )
                 responses.append(response)
 
+            # NOTE: 按讚反讚功能已暫時停用（2025-12-03），日後需要可以取消註解以下程式碼
             # 處理使用者藉由按讚反讚按鈕反饋的postback事件
-            elif isinstance(event, PostbackEvent):
-                await handle_feedback(event, line_bot_api)
-                responses.append("feedback_handled")
+            # elif isinstance(event, PostbackEvent):
+            #     await handle_feedback(event, line_bot_api)
+            #     responses.append("feedback_handled")
 
     return {"responses": responses}
 
@@ -963,34 +964,40 @@ async def handle_message(
                 )
             )
 
+        # NOTE: 按讚反讚功能已暫時停用（2025-12-03），日後需要可以取消註解以下程式碼
         # 以 Quick Reply 作為按讚反讚按鈕
-        quick_reply = QuickReply(
-            items=[
-                QuickReplyItem(
-                    action=PostbackAction(
-                        label="津好康，真是棒👍🏻",
-                        data="實用",
-                        display_text="津好康，真是棒👍🏻",
-                    )
-                ),
-                QuickReplyItem(
-                    action=PostbackAction(
-                        label="津可惜，不太實用😖",
-                        data="不實用",
-                        display_text="津可惜，不太實用😖",
-                    )
-                ),
-            ]
-        )
+        # quick_reply = QuickReply(
+        #     items=[
+        #         QuickReplyItem(
+        #             action=PostbackAction(
+        #                 label="津好康，真是棒👍🏻",
+        #                 data="實用",
+        #                 display_text="津好康，真是棒👍🏻",
+        #             )
+        #         ),
+        #         QuickReplyItem(
+        #             action=PostbackAction(
+        #                 label="津可惜，不太實用😖",
+        #                 data="不實用",
+        #                 display_text="津可惜，不太實用😖",
+        #             )
+        #         ),
+        #     ]
+        # )
 
         if question_bubble:
             messages.append(FlexMessage(alt_text="相關問題", contents=question_bubble))
 
-        messages[-1].quick_reply = quick_reply
-
+        # messages[-1].quick_reply = quick_reply
+        logging.info(
+            f"[Line Bot Webhook: handle_message] start reply_message"
+        )
         await line_bot_api.reply_message(
             ReplyMessageRequest(reply_token=event.reply_token, messages=messages)
         )
+        logging.info(
+            f"[Line Bot Webhook: handle_message] end reply_message"
+        )
     except Exception as e:
         traceback.print_exc()
         logging.error(
@@ -1085,14 +1092,15 @@ async def get_reply_text(
 
     try:
         # 取得系統指令
-        system_instruction = get_subsidy_api_system_prompt()
+        # 暫時不需要，因為現在是直接呼叫 cbh 的 api, prompt 在它裡面
+        # system_instruction = get_subsidy_api_system_prompt()
 
         # 調用外部 API
         api_response = await call_subsidy_api(
             user_message=line_user_message,
             user_id=user_id,
             display_name=display_name,
-            system_instruction=system_instruction
+            # system_instruction=system_instruction
         )
 
         # 提取 token 使用量資訊

botrun_flow_lang/langgraph_agents/agents/agent_runner.py

@@ -71,15 +71,19 @@ async def langgraph_runner(
             # 設定新的 recursion_limit 為 (multiplier + 1) * MAX_RECURSION_LIMIT
             config["recursion_limit"] = (multiplier + 1) * MAX_RECURSION_LIMIT
 
-    async for event in graph.astream_events(
-        invoke_state,
-        config,
-        version="v2",
-    ):
-        # state = await graph.aget_state(config)
-        # print(state.config)
-
-        yield event
+    try:
+        async for event in graph.astream_events(
+                invoke_state,
+                config,
+                version="v2",
+        ):
+            yield event
+    except Exception as e:
+        # 捕獲 SSE 流讀取錯誤（如 httpcore.ReadError）
+        import logging
+        logging.error(f"Error reading SSE stream: {e}", exc_info=True)
+        # 產生錯誤 event 讓調用者知道
+        yield {"error": f"SSE stream error: {str(e)}"}
 
 
 # graph 是 CompiledStateGraph，不傳入型別的原因是，loading import 需要 0.5秒

botrun_flow_lang/langgraph_agents/agents/util/pdf_analyzer.py

@@ -1,14 +1,32 @@
+"""
+PDF 分析模組
+
+提供 PDF 檔案分析功能，支援：
+- 小檔 (< 5MB)：直接多模態問答
+- 大檔 (>= 5MB)：壓縮 → 切割 → 平行多模態問答 → LLM 統整結果
+"""
+
 import anthropic
+import asyncio
 import base64
 import httpx
-
-
 import os
+from typing import List, Dict, Any
+
 from dotenv import load_dotenv
 from google.oauth2 import service_account
 
 load_dotenv()
 
+# 檔案大小閾值（MB）
+PDF_SIZE_THRESHOLD_MB = 30.0
+
+# 切片目標大小（MB）
+PDF_CHUNK_TARGET_SIZE_MB = 30.0
+
+# 最大平行問答數量
+MAX_CONCURRENT_CHUNKS = 5
+
 
 def analyze_pdf_with_claude(
     pdf_data: str, user_input: str, model_name: str = "claude-sonnet-4-5-20250929"
@@ -55,7 +73,7 @@ def analyze_pdf_with_claude(
 
 
 def analyze_pdf_with_gemini(
-    pdf_data: str, user_input: str, model_name: str = "gemini-2.5-flash"
+    pdf_data: str, user_input: str, model_name: str = "gemini-2.5-flash", pdf_url: str = ""
 ):
     """
     Analyze a PDF file using Gemini API
@@ -100,61 +118,369 @@ def analyze_pdf_with_gemini(
             f"analyze_pdf_with_gemini============> input_token: {response.usage_metadata.prompt_token_count} output_token: {response.usage_metadata.candidates_token_count}",
         )
 
+    print(f"{pdf_url} success")
     return response.text
 
 
-def analyze_pdf(pdf_url: str, user_input: str):
+def _analyze_single_chunk(
+    chunk_data: str, page_range: str, user_input: str, model_name: str
+) -> Dict[str, Any]:
+    """
+    分析單一 PDF 切片
+
+    Args:
+        chunk_data: Base64-encoded PDF chunk data
+        page_range: 頁碼範圍字串 (e.g., "page-001-015")
+        user_input: 使用者問題
+        model_name: 使用的模型名稱
+
+    Returns:
+        Dict: {"page_range": str, "answer": str, "relevant": bool, "error": str|None}
+    """
+    # 構建切片專用的 prompt
+    chunk_prompt = f"""你正在閱讀一份大型 PDF 文件的其中一部分（{page_range}）。
+
+使用者問題：{user_input}
+
+請根據這個部分的內容回答問題：
+- 如果這個部分包含與問題相關的資訊，請詳細回答
+- 如果這個部分與問題完全無關，請只回答「NOT_RELEVANT」（不要回答其他內容）
+- 回答時請標註資訊來源的頁碼"""
+
+    try:
+        if model_name.startswith("gemini-"):
+            answer = analyze_pdf_with_gemini(chunk_data, chunk_prompt, model_name)
+        elif model_name.startswith("claude-"):
+            answer = analyze_pdf_with_claude(chunk_data, chunk_prompt, model_name)
+        else:
+            return {
+                "page_range": page_range,
+                "answer": "",
+                "relevant": False,
+                "error": f"Unknown model type: {model_name}",
+            }
+
+        # 判斷是否相關
+        is_relevant = "NOT_RELEVANT" not in answer.upper()
+
+        return {
+            "page_range": page_range,
+            "answer": answer if is_relevant else "",
+            "relevant": is_relevant,
+            "error": None,
+        }
+
+    except Exception as e:
+        import traceback
+
+        traceback.print_exc()
+        return {
+            "page_range": page_range,
+            "answer": "",
+            "relevant": False,
+            "error": str(e),
+        }
+
+
+async def analyze_pdf_chunks_parallel(
+    chunks: List[tuple], user_input: str, model_name: str, max_concurrent: int = 5
+) -> List[Dict[str, Any]]:
     """
-    Analyze a PDF file using multiple models in order of preference based on PDF_ANALYZER_MODEL env var
+    平行問答多個 PDF 切片
+
+    Args:
+        chunks: 切片清單 [(chunk_bytes, page_range), ...]
+        user_input: 使用者問題
+        model_name: 使用的模型名稱
+        max_concurrent: 最大平行數量
+
+    Returns:
+        List[Dict]: 每個切片的回答結果
+    """
+    semaphore = asyncio.Semaphore(max_concurrent)
+
+    async def analyze_with_semaphore(chunk_bytes: bytes, page_range: str):
+        async with semaphore:
+            # 將 bytes 轉為 base64
+            chunk_data = base64.standard_b64encode(chunk_bytes).decode("utf-8")
+
+            # 使用 run_in_executor 執行同步函數
+            loop = asyncio.get_event_loop()
+            return await loop.run_in_executor(
+                None,
+                _analyze_single_chunk,
+                chunk_data,
+                page_range,
+                user_input,
+                model_name,
+            )
+
+    # 建立所有任務
+    tasks = [
+        analyze_with_semaphore(chunk_bytes, page_range)
+        for chunk_bytes, page_range in chunks
+    ]
+
+    # 平行執行
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    # 處理例外
+    processed_results = []
+    for i, result in enumerate(results):
+        if isinstance(result, Exception):
+            processed_results.append(
+                {
+                    "page_range": chunks[i][1],
+                    "answer": "",
+                    "relevant": False,
+                    "error": str(result),
+                }
+            )
+        else:
+            processed_results.append(result)
+
+    return processed_results
 
-    If PDF_ANALYZER_MODEL contains comma-separated models, it will try them in order,
-    falling back to the next one if the previous fails.
+
+def merge_chunk_results(
+    chunk_results: List[Dict[str, Any]],
+    user_input: str,
+    model_name: str = "gemini-2.5-flash",
+) -> str:
+    """
+    使用 LLM 統整多個切片的回答
 
     Args:
-        pdf_url: URL to the PDF file
-        user_input: User's query about the PDF content
+        chunk_results: 切片回答結果清單
+        user_input: 原始使用者問題
+        model_name: 統整使用的模型名稱
+
+    Returns:
+        str: 統整後的回答
+    """
+    # 過濾出相關的回答
+    relevant_results = [r for r in chunk_results if r.get("relevant", False)]
+
+    if not relevant_results:
+        # 沒有找到相關內容
+        error_results = [r for r in chunk_results if r.get("error")]
+        if error_results:
+            error_msgs = [f"{r['page_range']}: {r['error']}" for r in error_results]
+            return f"分析 PDF 時發生錯誤：\n" + "\n".join(error_msgs)
+        return "在 PDF 文件中未找到與您問題相關的內容。"
+
+    # 只有一個相關結果，直接回傳
+    if len(relevant_results) == 1:
+        return relevant_results[0]["answer"]
+
+    # 多個相關結果，需要統整
+    combined_content = "\n\n".join(
+        [
+            f"【{r['page_range']}】\n{r['answer']}"
+            for r in relevant_results
+        ]
+    )
+
+    merge_prompt = f"""以下是從一份大型 PDF 文件的不同部分擷取的回答，請統整這些資訊來回答使用者的問題。
+
+使用者問題：{user_input}
+
+各部分的回答：
+{combined_content}
+
+請統整以上資訊，提供一個完整、連貫的回答。如果不同部分有互補的資訊，請整合在一起。請保留頁碼引用。"""
+
+    try:
+        # 使用 LLM 統整（這裡不需要傳 PDF，只是純文字統整）
+        from google import genai
+
+        credentials = service_account.Credentials.from_service_account_file(
+            os.getenv("GOOGLE_APPLICATION_CREDENTIALS_FOR_FASTAPI"),
+            scopes=["https://www.googleapis.com/auth/cloud-platform"],
+        )
+
+        client = genai.Client(
+            credentials=credentials,
+            project="scoop-386004",
+            location="us-central1",
+        )
+
+        response = client.models.generate_content(
+            model=model_name,
+            contents=[merge_prompt],
+        )
+
+        if hasattr(response, "usage_metadata"):
+            print(
+                f"merge_chunk_results============> input_token: {response.usage_metadata.prompt_token_count} output_token: {response.usage_metadata.candidates_token_count}",
+            )
+
+        return response.text
+
+    except Exception as e:
+        import traceback
+
+        traceback.print_exc()
+        # 統整失敗，直接回傳合併的內容
+        return f"統整時發生錯誤，以下是各部分的回答：\n\n{combined_content}"
+
+
+async def analyze_pdf_async(pdf_url: str, user_input: str) -> str:
+    """
+    非同步分析 PDF 檔案（智慧處理策略）
+
+    根據檔案大小自動選擇處理策略：
+    - < 5MB: 直接多模態問答
+    - >= 5MB: 壓縮 → 切割 → 平行多模態問答 → LLM 統整結果
+
+    Args:
+        pdf_url: PDF 檔案的 URL
+        user_input: 使用者問題
 
     Returns:
-        str: Analysis of the PDF content based on the query
+        str: 分析結果
     """
     try:
-        # Download and encode the PDF file from URL
-        pdf_data = base64.standard_b64encode(httpx.get(pdf_url).content).decode("utf-8")
+        # 1. 下載 PDF
+        print(f"[analyze_pdf_async] 下載 PDF: {pdf_url}")
+        pdf_content = httpx.get(pdf_url, timeout=60.0).content
+        pdf_size_mb = len(pdf_content) / (1024 * 1024)
+        print(f"[analyze_pdf_async] PDF 大小: {pdf_size_mb:.2f} MB")
 
-        # Get models list from environment variable
+        # 取得模型設定
         models_str = os.getenv("PDF_ANALYZER_MODEL", "gemini-2.5-flash")
-        print(f"[analyze_pdf] 分析PDF使用模型: {models_str}")
+        print(f"[analyze_pdf_async] 使用模型: {models_str}")
         models = [model.strip() for model in models_str.split(",")]
+        primary_model = models[0]
+
+        # 2. 判斷處理策略
+        if pdf_size_mb < PDF_SIZE_THRESHOLD_MB:
+            # 小檔：直接多模態問答
+            print(f"[analyze_pdf_async] 小檔模式 (< {PDF_SIZE_THRESHOLD_MB}MB)")
+            pdf_data = base64.standard_b64encode(pdf_content).decode("utf-8")
 
-        last_error = None
-
-        # Try each model in order
-        for model in models:
-            try:
-                if model.startswith("gemini-"):
-                    print(f"Trying to analyze PDF with Gemini model: {model}")
-                    return analyze_pdf_with_gemini(pdf_data, user_input, model)
-                elif model.startswith("claude-"):
-                    print(f"Trying to analyze PDF with Claude model: {model}")
-                    return analyze_pdf_with_claude(pdf_data, user_input, model)
-                else:
-                    print(f"Unknown model type: {model}, skipping")
+            # 嘗試所有模型
+            last_error = None
+            for model in models:
+                try:
+                    if model.startswith("gemini-"):
+                        return analyze_pdf_with_gemini(pdf_data, user_input, model, pdf_url)
+                    elif model.startswith("claude-"):
+                        return analyze_pdf_with_claude(pdf_data, user_input, model)
+                except Exception as e:
+                    import traceback
+
+                    traceback.print_exc()
+                    last_error = str(e)
                     continue
-            except Exception as e:
-                import traceback
-
-                traceback.print_exc()
-                error_msg = f"Error analyzing PDF with {model}: {str(e)}"
-                print(error_msg)
-                last_error = error_msg
-                # Continue to the next model in the list
-                continue
-
-        # If we've reached here, all models failed
-        return (
-            f"Error analyzing PDF with all specified models. Last error: {last_error}"
+
+            return f"分析 PDF 時所有模型都失敗。最後錯誤: {last_error}"
+
+        # 3. 大檔：壓縮 → 切割 → 平行問答 → 統整
+        print(f"[analyze_pdf_async] 大檔模式 (>= {PDF_SIZE_THRESHOLD_MB}MB)")
+
+        # 延遲 import 以加快載入
+        from botrun_flow_lang.langgraph_agents.agents.util.pdf_processor import (
+            split_pdf_smart,
+            get_pdf_page_count,
+        )
+        from botrun_flow_lang.langgraph_agents.agents.util.pdf_cache import (
+            get_cache_key,
+            check_cache,
+            save_to_cache,
         )
 
+        # 3.1 檢查快取
+        cache_key = get_cache_key(pdf_url)
+        print(f"[analyze_pdf_async] 檢查快取: {cache_key}")
+        cached_chunks = await check_cache(cache_key)
+
+        if cached_chunks:
+            # 有快取，直接使用
+            print(f"[analyze_pdf_async] 使用快取: {len(cached_chunks)} 個切片")
+            chunks = cached_chunks
+            total_pages = sum(
+                int(pr.split("-")[-1]) - int(pr.split("-")[-2]) + 1
+                for _, pr in chunks
+                if pr.startswith("page-")
+            ) if chunks else 0
+        else:
+            # 無快取，切割後存入快取
+
+            # 3.2 切割
+            print("[analyze_pdf_async] 切割 PDF...")
+            chunks = split_pdf_smart(pdf_content, target_size_mb=PDF_CHUNK_TARGET_SIZE_MB)
+            total_pages = get_pdf_page_count(pdf_content)
+            print(
+                f"[analyze_pdf_async] 切割完成: {len(chunks)} 個切片, 共 {total_pages} 頁"
+            )
+
+            # 3.3 存入快取
+            print("[analyze_pdf_async] 存入快取...")
+            await save_to_cache(
+                cache_key=cache_key,
+                chunks=chunks,
+                original_url=pdf_url,
+                original_size_mb=pdf_size_mb,
+                total_pages=total_pages,
+            )
+
+        # 3.3 平行問答
+        print(f"[analyze_pdf_async] 開始平行問答 (最大並行: {MAX_CONCURRENT_CHUNKS})...")
+        chunk_results = await analyze_pdf_chunks_parallel(
+            chunks, user_input, primary_model, max_concurrent=MAX_CONCURRENT_CHUNKS
+        )
+
+        # 統計結果
+        relevant_count = sum(1 for r in chunk_results if r.get("relevant", False))
+        error_count = sum(1 for r in chunk_results if r.get("error"))
+        print(
+            f"[analyze_pdf_async] 問答完成: {relevant_count}/{len(chunks)} 個切片有相關內容, "
+            f"{error_count} 個錯誤"
+        )
+
+        # 3.4 統整結果
+        print("[analyze_pdf_async] 統整結果...")
+        result = merge_chunk_results(chunk_results, user_input, primary_model)
+        print("[analyze_pdf_async] 完成")
+
+        return result
+
     except Exception as e:
-        print(f"Error downloading PDF: {str(e)}")
-        return f"Error downloading PDF: {str(e)}"
+        import traceback
+
+        traceback.print_exc()
+        return f"分析 PDF {pdf_url} 時發生錯誤: {str(e)}"
+
+
+def analyze_pdf(pdf_url: str, user_input: str) -> str:
+    """
+    分析 PDF 檔案（同步包裝函數）
+
+    這是一個同步函數，內部會建立事件迴圈來執行非同步的 analyze_pdf_async。
+    為了向後相容，保留這個同步介面。
+
+    Args:
+        pdf_url: PDF 檔案的 URL
+        user_input: 使用者問題
+
+    Returns:
+        str: 分析結果
+    """
+    try:
+        # 嘗試取得現有的事件迴圈
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # 如果已經在事件迴圈中，建立新的任務
+            import concurrent.futures
+
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(
+                    asyncio.run, analyze_pdf_async(pdf_url, user_input)
+                )
+                return future.result()
+        else:
+            return loop.run_until_complete(analyze_pdf_async(pdf_url, user_input))
+    except RuntimeError:
+        # 沒有事件迴圈，建立新的
+        return asyncio.run(analyze_pdf_async(pdf_url, user_input))

botrun_flow_lang/langgraph_agents/agents/util/pdf_cache.py

@@ -0,0 +1,250 @@
+"""
+PDF 快取模組
+
+提供 PDF 切片的 GCS 快取功能，避免重複切割相同的 PDF 檔案。
+快取會自動在 7 天後過期（透過 GCS Lifecycle Rule）。
+"""
+
+import hashlib
+import json
+from io import BytesIO
+from typing import List, Tuple, Optional
+from datetime import datetime
+
+from botrun_flow_lang.services.storage.storage_factory import storage_store_factory
+
+# 快取目錄前綴
+PDF_CACHE_PREFIX = "pdf-cache"
+
+# 快取過期天數（用於 lifecycle rule）
+PDF_CACHE_EXPIRY_DAYS = 7
+
+
+def get_cache_key(pdf_url: str) -> str:
+    """
+    根據 PDF URL 產生快取 key（hash）
+
+    Args:
+        pdf_url: PDF 檔案的 URL
+
+    Returns:
+        str: 32 字元的 MD5 hash
+    """
+    return hashlib.md5(pdf_url.encode()).hexdigest()
+
+
+def _get_cache_path(cache_key: str) -> str:
+    """
+    取得快取目錄路徑
+
+    Args:
+        cache_key: 快取 key
+
+    Returns:
+        str: GCS 路徑，格式為 "pdf-cache/{cache_key}"
+    """
+    return f"{PDF_CACHE_PREFIX}/{cache_key}"
+
+
+def _get_metadata_path(cache_key: str) -> str:
+    """取得 metadata 檔案路徑"""
+    return f"{_get_cache_path(cache_key)}/metadata.json"
+
+
+def _get_chunk_path(cache_key: str, chunk_index: int) -> str:
+    """取得切片檔案路徑"""
+    return f"{_get_cache_path(cache_key)}/chunk-{chunk_index:03d}.pdf"
+
+
+async def check_cache(cache_key: str) -> Optional[List[Tuple[bytes, str]]]:
+    """
+    檢查 GCS 是否有快取
+
+    Args:
+        cache_key: 快取 key（來自 get_cache_key）
+
+    Returns:
+        Optional[List[Tuple[bytes, str]]]: 如果有快取，回傳切片清單；否則回傳 None
+    """
+    try:
+        storage = storage_store_factory()
+        metadata_path = _get_metadata_path(cache_key)
+
+        # 檢查 metadata 檔案是否存在
+        if not await storage.file_exists(metadata_path):
+            print(f"[pdf_cache] 快取不存在: {cache_key}")
+            return None
+
+        # 讀取 metadata
+        metadata_file = await storage.retrieve_file(metadata_path)
+        if not metadata_file:
+            print(f"[pdf_cache] 無法讀取 metadata: {cache_key}")
+            return None
+
+        metadata = json.loads(metadata_file.getvalue().decode("utf-8"))
+        chunk_count = metadata.get("chunk_count", 0)
+        page_ranges = metadata.get("page_ranges", [])
+
+        if chunk_count == 0:
+            print(f"[pdf_cache] 快取無切片: {cache_key}")
+            return None
+
+        print(f"[pdf_cache] 找到快取: {cache_key}, {chunk_count} 個切片")
+
+        # 讀取所有切片
+        chunks = []
+        for i in range(chunk_count):
+            chunk_path = _get_chunk_path(cache_key, i)
+            chunk_file = await storage.retrieve_file(chunk_path)
+
+            if not chunk_file:
+                print(f"[pdf_cache] 無法讀取切片 {i}: {cache_key}")
+                return None  # 快取不完整，放棄使用
+
+            chunk_bytes = chunk_file.getvalue()
+            page_range = page_ranges[i] if i < len(page_ranges) else f"chunk-{i:03d}"
+            chunks.append((chunk_bytes, page_range))
+
+        print(f"[pdf_cache] 成功載入快取: {cache_key}")
+        return chunks
+
+    except Exception as e:
+        print(f"[pdf_cache] 檢查快取時發生錯誤: {e}")
+        return None
+
+
+async def save_to_cache(
+    cache_key: str,
+    chunks: List[Tuple[bytes, str]],
+    original_url: str,
+    original_size_mb: float,
+    total_pages: int,
+) -> bool:
+    """
+    將切片存入 GCS 快取
+
+    Args:
+        cache_key: 快取 key
+        chunks: 切片清單 [(chunk_bytes, page_range), ...]
+        original_url: 原始 PDF URL
+        original_size_mb: 原始檔案大小（MB）
+        total_pages: 總頁數
+
+    Returns:
+        bool: 是否成功存入快取
+    """
+    try:
+        storage = storage_store_factory()
+
+        # 1. 存入所有切片
+        page_ranges = []
+        for i, (chunk_bytes, page_range) in enumerate(chunks):
+            chunk_path = _get_chunk_path(cache_key, i)
+            chunk_file = BytesIO(chunk_bytes)
+
+            success, _ = await storage.store_file(
+                chunk_path, chunk_file, public=False, content_type="application/pdf"
+            )
+
+            if not success:
+                print(f"[pdf_cache] 無法存入切片 {i}: {cache_key}")
+                return False
+
+            page_ranges.append(page_range)
+
+        # 2. 存入 metadata
+        metadata = {
+            "original_url": original_url,
+            "cache_key": cache_key,
+            "chunk_count": len(chunks),
+            "page_ranges": page_ranges,
+            "original_size_mb": original_size_mb,
+            "total_pages": total_pages,
+            "created_at": datetime.utcnow().isoformat(),
+        }
+
+        metadata_path = _get_metadata_path(cache_key)
+        metadata_file = BytesIO(json.dumps(metadata, ensure_ascii=False).encode("utf-8"))
+
+        success, _ = await storage.store_file(
+            metadata_path, metadata_file, public=False, content_type="application/json"
+        )
+
+        if not success:
+            print(f"[pdf_cache] 無法存入 metadata: {cache_key}")
+            return False
+
+        print(
+            f"[pdf_cache] 成功存入快取: {cache_key}, "
+            f"{len(chunks)} 個切片, {total_pages} 頁"
+        )
+        return True
+
+    except Exception as e:
+        print(f"[pdf_cache] 存入快取時發生錯誤: {e}")
+        return False
+
+
+async def get_cache_metadata(cache_key: str) -> Optional[dict]:
+    """
+    取得快取的 metadata（不載入切片內容）
+
+    Args:
+        cache_key: 快取 key
+
+    Returns:
+        Optional[dict]: metadata 字典，或 None
+    """
+    try:
+        storage = storage_store_factory()
+        metadata_path = _get_metadata_path(cache_key)
+
+        if not await storage.file_exists(metadata_path):
+            return None
+
+        metadata_file = await storage.retrieve_file(metadata_path)
+        if not metadata_file:
+            return None
+
+        return json.loads(metadata_file.getvalue().decode("utf-8"))
+
+    except Exception as e:
+        print(f"[pdf_cache] 讀取 metadata 時發生錯誤: {e}")
+        return None
+
+
+async def delete_cache(cache_key: str) -> bool:
+    """
+    刪除快取
+
+    Args:
+        cache_key: 快取 key
+
+    Returns:
+        bool: 是否成功刪除
+    """
+    try:
+        storage = storage_store_factory()
+
+        # 先讀取 metadata 取得切片數量
+        metadata = await get_cache_metadata(cache_key)
+        if not metadata:
+            return True  # 快取不存在，視為成功
+
+        chunk_count = metadata.get("chunk_count", 0)
+
+        # 刪除所有切片
+        for i in range(chunk_count):
+            chunk_path = _get_chunk_path(cache_key, i)
+            await storage.delete_file(chunk_path)
+
+        # 刪除 metadata
+        metadata_path = _get_metadata_path(cache_key)
+        await storage.delete_file(metadata_path)
+
+        print(f"[pdf_cache] 已刪除快取: {cache_key}")
+        return True
+
+    except Exception as e:
+        print(f"[pdf_cache] 刪除快取時發生錯誤: {e}")
+        return False

botrun_flow_lang/langgraph_agents/agents/util/pdf_processor.py

@@ -0,0 +1,204 @@
+"""
+PDF 處理工具模組
+
+提供 PDF 切割等功能，用於處理大型 PDF 檔案。
+使用 pypdf（純 Python）實作，避免 C++ 庫的 segfault 問題。
+"""
+
+import io
+from typing import List, Tuple
+
+from pypdf import PdfReader, PdfWriter
+
+
+def get_pdf_size(pdf_content: bytes) -> int:
+    """
+    取得 PDF 檔案大小（bytes）
+
+    Args:
+        pdf_content: PDF 檔案的二進位內容
+
+    Returns:
+        int: 檔案大小（bytes）
+    """
+    return len(pdf_content)
+
+
+def get_pdf_size_mb(pdf_content: bytes) -> float:
+    """
+    取得 PDF 檔案大小（MB）
+
+    Args:
+        pdf_content: PDF 檔案的二進位內容
+
+    Returns:
+        float: 檔案大小（MB）
+    """
+    return len(pdf_content) / (1024 * 1024)
+
+
+def get_pdf_page_count(pdf_content: bytes) -> int:
+    """
+    取得 PDF 總頁數
+
+    Args:
+        pdf_content: PDF 檔案的二進位內容
+
+    Returns:
+        int: 總頁數
+    """
+    try:
+        reader = PdfReader(io.BytesIO(pdf_content))
+        return len(reader.pages)
+    except Exception as e:
+        print(f"[get_pdf_page_count] 無法讀取 PDF 頁數: {e}")
+        return 0
+
+
+def split_pdf_by_pages(
+    pdf_content: bytes, pages_per_chunk: int = 15
+) -> List[Tuple[bytes, str]]:
+    """
+    按頁數切割 PDF
+
+    Args:
+        pdf_content: PDF 檔案的二進位內容
+        pages_per_chunk: 每個切片的頁數（預設 15 頁）
+
+    Returns:
+        List[Tuple[bytes, str]]: 切片清單，每個元素為 (切片內容, 頁碼範圍字串)
+        例如: [(chunk_bytes, "page-001-015"), (chunk_bytes, "page-016-030"), ...]
+    """
+    chunks = []
+
+    try:
+        reader = PdfReader(io.BytesIO(pdf_content))
+        total_pages = len(reader.pages)
+
+        for start_idx in range(0, total_pages, pages_per_chunk):
+            end_idx = min(start_idx + pages_per_chunk, total_pages)
+
+            # 建立新的 PDF 並複製頁面
+            writer = PdfWriter()
+            for page_idx in range(start_idx, end_idx):
+                writer.add_page(reader.pages[page_idx])
+
+            # 輸出切片
+            output = io.BytesIO()
+            writer.write(output)
+            chunk_bytes = output.getvalue()
+
+            # 產生頁碼範圍字串（1-indexed）
+            page_range = f"page-{start_idx + 1:03d}-{end_idx:03d}"
+
+            chunks.append((chunk_bytes, page_range))
+
+    except Exception as e:
+        print(f"[split_pdf_by_pages] 切割 PDF 時發生錯誤: {e}")
+        # 如果切割失敗，回傳整個 PDF 作為單一切片
+        if pdf_content:
+            chunks.append((pdf_content, "page-001-all"))
+
+    return chunks
+
+
+def calculate_optimal_chunk_size(
+    pdf_content: bytes,
+    target_size_mb: float = 4.0,
+    min_pages: int = 5,
+    max_pages: int = 30,
+) -> int:
+    """
+    計算最佳切割頁數，確保每個切片小於目標大小
+
+    策略：
+    1. 先估算每頁平均大小
+    2. 計算達到目標大小需要的頁數
+    3. 限制在 min_pages 和 max_pages 之間
+
+    Args:
+        pdf_content: PDF 檔案的二進位內容
+        target_size_mb: 目標切片大小（MB），預設 4MB
+        min_pages: 最小頁數，預設 5 頁
+        max_pages: 最大頁數，預設 30 頁
+
+    Returns:
+        int: 建議的每個切片頁數
+    """
+    total_size_mb = get_pdf_size_mb(pdf_content)
+    total_pages = get_pdf_page_count(pdf_content)
+
+    if total_pages == 0:
+        return min_pages
+
+    # 估算每頁平均大小
+    avg_page_size_mb = total_size_mb / total_pages
+
+    # 計算達到目標大小需要的頁數
+    if avg_page_size_mb > 0:
+        optimal_pages = int(target_size_mb / avg_page_size_mb)
+    else:
+        optimal_pages = max_pages
+
+    # 限制在範圍內
+    optimal_pages = max(min_pages, min(optimal_pages, max_pages))
+
+    return optimal_pages
+
+
+def split_pdf_smart(
+    pdf_content: bytes, target_size_mb: float = 4.0
+) -> List[Tuple[bytes, str]]:
+    """
+    智慧切割 PDF
+
+    先計算最佳切割頁數，然後進行切割。
+    如果切割後某個切片仍超過目標大小，會進一步分割。
+
+    Args:
+        pdf_content: PDF 檔案的二進位內容
+        target_size_mb: 目標切片大小（MB），預設 4MB
+
+    Returns:
+        List[Tuple[bytes, str]]: 切片清單，每個元素為 (切片內容, 頁碼範圍字串)
+    """
+    # 計算最佳切割頁數
+    pages_per_chunk = calculate_optimal_chunk_size(pdf_content, target_size_mb)
+    print(f"[split_pdf_smart] 計算最佳切割頁數: {pages_per_chunk} 頁/切片")
+
+    # 進行初步切割
+    chunks = split_pdf_by_pages(pdf_content, pages_per_chunk)
+
+    # 檢查是否有切片超過目標大小，如果有則進一步分割
+    final_chunks = []
+    for chunk_bytes, page_range in chunks:
+        chunk_size_mb = get_pdf_size_mb(chunk_bytes)
+
+        if chunk_size_mb > target_size_mb and pages_per_chunk > 5:
+            # 這個切片太大，需要進一步分割
+            print(
+                f"[split_pdf_smart] 切片 {page_range} 大小 {chunk_size_mb:.2f}MB "
+                f"超過目標 {target_size_mb}MB，進一步分割"
+            )
+
+            # 取得這個切片的頁碼範圍
+            parts = page_range.replace("page-", "").split("-")
+            start_page = int(parts[0])
+
+            # 用更小的頁數重新切割
+            smaller_chunks = split_pdf_by_pages(chunk_bytes, pages_per_chunk // 2)
+
+            # 更新頁碼範圍
+            chunk_page_count = get_pdf_page_count(chunk_bytes)
+            for i, (sub_chunk, _) in enumerate(smaller_chunks):
+                sub_start = start_page + i * (pages_per_chunk // 2)
+                sub_end = min(
+                    sub_start + (pages_per_chunk // 2) - 1,
+                    start_page + chunk_page_count - 1,
+                )
+                sub_range = f"page-{sub_start:03d}-{sub_end:03d}"
+                final_chunks.append((sub_chunk, sub_range))
+        else:
+            final_chunks.append((chunk_bytes, page_range))
+
+    return final_chunks

botrun_flow_lang/mcp_server/default_mcp.py

@@ -15,7 +15,9 @@ from langchain_core.runnables import RunnableConfig
 
 # Import necessary dependencies
 from botrun_flow_lang.models.nodes.utils import scrape_single_url
-from botrun_flow_lang.langgraph_agents.agents.util.pdf_analyzer import analyze_pdf
+from botrun_flow_lang.langgraph_agents.agents.util.pdf_analyzer import (
+    analyze_pdf_async,
+)
 from botrun_flow_lang.langgraph_agents.agents.util.img_util import analyze_imgs
 from botrun_flow_lang.langgraph_agents.agents.util.local_files import (
     upload_and_get_tmp_public_url,
@@ -76,6 +78,10 @@ async def chat_with_pdf(
     """
     Analyze a PDF file and answer questions about its content.
 
+    Supports intelligent processing based on file size:
+    - Small files (< 5MB): Direct multimodal analysis
+    - Large files (>= 5MB): Compress -> Split -> Parallel multimodal Q&A -> Merge results
+
     Args:
         pdf_url: The URL to the PDF file (can be generated using generate_tmp_public_url for local files)
         user_input: The user's question or instruction about the PDF content
@@ -91,7 +97,7 @@ async def chat_with_pdf(
     if not pdf_url.startswith("http"):
         pdf_url = upload_and_get_tmp_public_url(pdf_url, botrun_flow_lang_url, user_id)
 
-    return analyze_pdf(pdf_url, user_input)
+    return await analyze_pdf_async(pdf_url, user_input)
 
 
 @mcp.tool()
@@ -175,10 +181,10 @@ async def generate_image(
         # 驗證必要參數
         if not user_id:
             logger.error("User ID not available")
-            raise Exception("User ID not available")
+            return "User ID not available"
         if not botrun_flow_lang_url:
             logger.error("botrun_flow_lang_url not available")
-            raise Exception("botrun_flow_lang_url not available")
+            return "botrun_flow_lang_url not available"
 
         # Check rate limit before generating image
         rate_limit_client = RateLimitClient()
@@ -195,10 +201,12 @@ async def generate_image(
                 f"User {user_id} has reached daily limit of {daily_limit} image generations. "
                 f"Current usage: {current_usage}. Please try again tomorrow."
             )
-            raise BotrunRateLimitException(
-                f"You have reached your daily limit of {daily_limit} image generations. "
+            return f"[Please tell user error] You have reached your daily limit of {daily_limit} image generations. " \
                 f"Current usage: {current_usage}. Please try again tomorrow."
-            )
+            # raise BotrunRateLimitException(
+            #     f"You have reached your daily limit of {daily_limit} image generations. "
+            #     f"Current usage: {current_usage}. Please try again tomorrow."
+            # )
 
         # 2. 使用 DALL-E 生成圖片
         dalle_wrapper = DallEAPIWrapper(
@@ -267,7 +275,8 @@ async def generate_tmp_public_url(
     logger.info(f"generate_tmp_public_url file_path: {file_path}")
 
     if not os.path.exists(file_path):
-        raise FileNotFoundError(f"File not found: {file_path}")
+        return f"File not found: {file_path}"
+        # raise FileNotFoundError(f"File not found: {file_path}")
 
     return upload_and_get_tmp_public_url(file_path, botrun_flow_lang_url, user_id)
 

botrun_flow_lang/services/hatch/hatch_fs_store.py

@@ -1,5 +1,6 @@
 import logging
 from typing import Union, List, Tuple
+from datetime import datetime, timezone
 from google.cloud.exceptions import GoogleCloudError
 from botrun_flow_lang.constants import HATCH_SHARING_STORE_NAME, HATCH_STORE_NAME
 from botrun_flow_lang.services.base.firestore_base import FirestoreBase
@@ -27,6 +28,9 @@ class HatchFsStore(FirestoreBase):
 
     async def set_hatch(self, item: Hatch):
         try:
+            # Update updated_at timestamp with current UTC time
+            item.updated_at = datetime.now(timezone.utc).isoformat()
+
             # Proceed with saving the hatch
             doc_ref = self.collection.document(str(item.id))
             doc_ref.set(item.model_dump())
@@ -49,18 +53,29 @@ class HatchFsStore(FirestoreBase):
             return False
 
     async def get_hatches(
-        self, user_id: str, offset: int = 0, limit: int = 20
+        self,
+        user_id: str,
+        offset: int = 0,
+        limit: int = 20,
+        sort_by: str = "updated_at",
+        order: str = "desc",
     ) -> Tuple[List[Hatch], str]:
         try:
-            query = (
-                self.collection.where(
-                    filter=firestore.FieldFilter("user_id", "==", user_id)
-                )
-                .order_by("name")
-                .offset(offset)
-                .limit(limit)
+            # Build base query
+            query = self.collection.where(
+                filter=firestore.FieldFilter("user_id", "==", user_id)
             )
 
+            # Add sorting
+            # Firestore direction: DESCENDING or ASCENDING
+            direction = (
+                firestore.Query.DESCENDING if order == "desc" else firestore.Query.ASCENDING
+            )
+            query = query.order_by(sort_by, direction=direction)
+
+            # Add pagination
+            query = query.offset(offset).limit(limit)
+
             docs = query.stream()
             hatches = [Hatch(**doc.to_dict()) for doc in docs]
             return hatches, ""

botrun_flow_lang/services/storage/storage_cs_store.py

@@ -39,7 +39,11 @@ class StorageCsStore(StorageStore):
                 {
                     "action": {"type": "Delete"},
                     "condition": {"age": 365, "matchesPrefix": ["tmp/"]},
-                }
+                },
+                {
+                    "action": {"type": "Delete"},
+                    "condition": {"age": 7, "matchesPrefix": ["pdf-cache/"]},
+                },
             ]
 
             if not bucket.exists():

{botrun_flow_lang-5.11.281.dist-info → botrun_flow_lang-5.12.261.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: botrun-flow-lang
-Version: 5.11.281
+Version: 5.12.261
 Summary: A flow language for botrun
 Author-email: sebastian-hsu <sebastian.hsu@gmail.com>
 License: MIT
@@ -13,7 +13,7 @@ Requires-Python: <3.13,>=3.11
 Requires-Dist: aiohttp>=3.10.8
 Requires-Dist: anthropic>=0.61.0
 Requires-Dist: boto3>=1.40.3
-Requires-Dist: botrun-hatch>=5.10.82
+Requires-Dist: botrun-hatch>=5.12.261
 Requires-Dist: botrun-log>=0.3.0
 Requires-Dist: cachetools>=5.5.2
 Requires-Dist: chardet>=5.2.0
@@ -47,6 +47,7 @@ Requires-Dist: pandas>=2.2.3
 Requires-Dist: pdfminer-six==20250506
 Requires-Dist: plotly>=6.0.0
 Requires-Dist: pydantic-settings>=2.5.2
+Requires-Dist: pypdf==6.4.2
 Requires-Dist: python-multipart>=0.0.20
 Requires-Dist: pytz>=2024.2
 Requires-Dist: pyyaml>=6.0.2

{botrun_flow_lang-5.11.281.dist-info → botrun_flow_lang-5.12.261.dist-info}/RECORD

@@ -8,9 +8,9 @@ botrun_flow_lang/api/auth_api.py,sha256=o_ThrZFcOMQieUcUJIF_B7rsyvbkCvOCjCjknl9G
 botrun_flow_lang/api/auth_utils.py,sha256=qE7RIPDnX30FPmhlgmlQNoVNkLU028x4SldVl6VC4KQ,6455
 botrun_flow_lang/api/botrun_back_api.py,sha256=mE2NSejaYIiE0L9GmNJbLc_FRWCy6BXlcqRwkB1kKmc,2397
 botrun_flow_lang/api/flow_api.py,sha256=DcxuoGE1OcbTgLSYKZ2SO9IdcH3UB5Ik3cVmX3v3-Po,108
-botrun_flow_lang/api/hatch_api.py,sha256=qZG-Wwi_8SHPuWNfbt-dhz-O41VYetTxrJzcVjHbJCo,15913
+botrun_flow_lang/api/hatch_api.py,sha256=trenrAJt95ufjpAzwuTvcCoJdMR2x4EZCuWBup9e4hA,16984
 botrun_flow_lang/api/langgraph_api.py,sha256=zqu0xeTiy2Pr4UL6vvGqVVAy2KX3ZUn1uzcq-Tfb_aM,29291
-botrun_flow_lang/api/line_bot_api.py,sha256=__Rul_JWd7KwtgGIyziOKxD9PSconkjuN0dmI8JEwjg,54930
+botrun_flow_lang/api/line_bot_api.py,sha256=INTWnI09LhRhQ6NcetHrHAQZU86eyoJ2zZ6g-KtX8MM,55500
 botrun_flow_lang/api/model_api.py,sha256=bXemey_XUUdylZwh7Z10eksoBWe9xSa8I9TEL7jIBtE,9483
 botrun_flow_lang/api/rate_limit_api.py,sha256=SkpjfvShHRdP5XJzy3DdrH4jLtdYAEHROGBMBkC9OIY,948
 botrun_flow_lang/api/routes.py,sha256=rd0IoMsteJT9BO3MQuyXirhPQbas6OeiKaEC8Yf2SZs,1570
@@ -23,7 +23,7 @@ botrun_flow_lang/api/version_api.py,sha256=Mcs7hKBP7T7nlHDaZS4U0dtOkNQqW0BtT62Iv
 botrun_flow_lang/api/youtube_api.py,sha256=R384jNRheMKnDyzvlLnbzackipZhiLYTZl4w4hB6vtw,753
 botrun_flow_lang/langgraph_agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 botrun_flow_lang/langgraph_agents/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-botrun_flow_lang/langgraph_agents/agents/agent_runner.py,sha256=fOZgHDsCA_EDTTGQFBmhGUhpfLB3m_N6YW2UHgMpKBg,6241
+botrun_flow_lang/langgraph_agents/agents/agent_runner.py,sha256=1BRIbEi7_NoIx1BuVUPFA-fDHErm3nHpX65HsY7YpWU,6495
 botrun_flow_lang/langgraph_agents/agents/langgraph_react_agent.py,sha256=4fK_hMoUAqcEYv7rrHbAx6PFsJ7UcvGI0G2OgWhVhnw,29972
 botrun_flow_lang/langgraph_agents/agents/search_agent_graph.py,sha256=6fz-ewLQGacEx-uqGfF3-go9FdiioiMzW_sfANzYTcI,31182
 botrun_flow_lang/langgraph_agents/agents/agent_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -44,7 +44,9 @@ botrun_flow_lang/langgraph_agents/agents/util/img_util.py,sha256=FF5XUFCtYBul6DZ
 botrun_flow_lang/langgraph_agents/agents/util/local_files.py,sha256=ib3JVvuTgKhFj-D_8d5MH3vImFe6Fk1aMxyxNqjDWWc,13110
 botrun_flow_lang/langgraph_agents/agents/util/mermaid_util.py,sha256=Aw_ufAEBAqSENOtueemYtapxPVvbQ6HScedeWUZ8lS4,2556
 botrun_flow_lang/langgraph_agents/agents/util/model_utils.py,sha256=lCORhM77agNgmDxsA40XlUth-E8ThM5Kv-x0_DQnYrs,4811
-botrun_flow_lang/langgraph_agents/agents/util/pdf_analyzer.py,sha256=u318H8mXS-qx3-te8fBEHUoOv0hkgXMVdvxlfY80w6g,5091
+botrun_flow_lang/langgraph_agents/agents/util/pdf_analyzer.py,sha256=R50ttYF9uun9aawjFzyFlTrXbM03HNbc-yanILdyRtM,15691
+botrun_flow_lang/langgraph_agents/agents/util/pdf_cache.py,sha256=ptWaNtu_ls1piiBqQG2ZISjxWJ4gxMbIs7hvBdeas5k,7125
+botrun_flow_lang/langgraph_agents/agents/util/pdf_processor.py,sha256=OgaloAzjoMmdymM3O1EiES7Ji6qqZtZPQmDT6HwmnYM,6040
 botrun_flow_lang/langgraph_agents/agents/util/perplexity_search.py,sha256=4ynmvT8yXbi4KFEVliXWffozB6fHd8jVueA3MmGKlD8,19073
 botrun_flow_lang/langgraph_agents/agents/util/plotly_util.py,sha256=8xKoj9ABwqCA8dzWFmw-qXCXStgCx6hMc5mVBBJ3ZGw,1913
 botrun_flow_lang/langgraph_agents/agents/util/tavily_search.py,sha256=hhiuxF6u92X8Mz1VLAreFrB-LyR-UOKR9Xxh1TBveTg,6623
@@ -56,7 +58,7 @@ botrun_flow_lang/llm_agent/llm_agent.py,sha256=Ae9YCK0R_zvSU38Oewo7_qbnBMYTaero6
 botrun_flow_lang/llm_agent/llm_agent_util.py,sha256=1slGk7LIYUylRjHvw4d92VAxD16uwiK4Efy0m_7tCJs,3048
 botrun_flow_lang/log/.gitignore,sha256=ZZ3Viy7hKc5dYybO_EM74DBeCqrwL7vmnECmsw--nVc,16
 botrun_flow_lang/mcp_server/__init__.py,sha256=P02XN_G9ALIeNgPwIsLPdKjGO7lk_XYOxME6NFrBrzE,208
-botrun_flow_lang/mcp_server/default_mcp.py,sha256=zkixaPFicuwJBx3B7DsQ9Drfj0FouPRcNY6Gm3B6y5E,28028
+botrun_flow_lang/mcp_server/default_mcp.py,sha256=P38E6p6s9yT2U33hxlOMXG0iioUQ-JgJze-9zmlu5mY,28490
 botrun_flow_lang/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 botrun_flow_lang/models/token_usage.py,sha256=hwGYZzklnTrcDCjNqCn03kddzS3VH-i1l0d5WnF6iqA,842
 botrun_flow_lang/models/nodes/utils.py,sha256=kN9RFOSHPvOZU7T4ZfVU6u2wkKgS03xtAKvjLOpryKM,6699
@@ -64,9 +66,9 @@ botrun_flow_lang/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 botrun_flow_lang/services/base/firestore_base.py,sha256=Z561TzGvYOUmGKc3IQh03nsK8XHCa96Nlx5m23TySks,1045
 botrun_flow_lang/services/hatch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 botrun_flow_lang/services/hatch/hatch_factory.py,sha256=ObCcb_hTp8YFXRNXOsXtI_dND_dz7cusypF2tDnMqYY,271
-botrun_flow_lang/services/hatch/hatch_fs_store.py,sha256=U8y5ipP2TBux06-sXGddmvkKDtsndUXDJfS54q7PJp8,13092
+botrun_flow_lang/services/hatch/hatch_fs_store.py,sha256=2wmRlFInjCD1RRRHVfX47xX74vih4zJBhfRcy5Uk7ew,13620
 botrun_flow_lang/services/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-botrun_flow_lang/services/storage/storage_cs_store.py,sha256=uGyYZ-2QVMhh29DwNKIEAp_Sdd_UV7LH3476MUbORTw,7730
+botrun_flow_lang/services/storage/storage_cs_store.py,sha256=5NQekxfzjH6420QHi6HxLFHM5qY9kfiYis-dmsyuHO4,7896
 botrun_flow_lang/services/storage/storage_factory.py,sha256=Yn40nB79qoEvClksIRnRpQGojXT4J4q1ExBqb3ydets,354
 botrun_flow_lang/services/storage/storage_store.py,sha256=cb31kDJHNqVA4HyiyJJ1Pnyqv1n5nOkHMpPpA8tvgXg,1905
 botrun_flow_lang/services/user_setting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -95,6 +97,6 @@ botrun_flow_lang/utils/yaml_utils.py,sha256=1A6PSEE8TM0HSD_6l-fhUsjYnXJcrEKuPgot
 botrun_flow_lang/utils/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 botrun_flow_lang/utils/clients/rate_limit_client.py,sha256=TRpA56OKrfYsoLoJ-TPYlC7Znp9s267-u6CX6BLyVko,8349
 botrun_flow_lang/utils/clients/token_verify_client.py,sha256=BtrfLvMe-DtS8UKeDhaIkVKDZHphZVP7kyqXn9jhXEc,5740
-botrun_flow_lang-5.11.281.dist-info/METADATA,sha256=BN-Ufk4sSRSkuAr3c8mIbKfh78gZX6yOMMxzq4oRSMo,6192
-botrun_flow_lang-5.11.281.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-botrun_flow_lang-5.11.281.dist-info/RECORD,,
+botrun_flow_lang-5.12.261.dist-info/METADATA,sha256=vtLwjT6C29pqio3IV9gFQeWSuVexlZuCs_bjkUmCw4s,6221
+botrun_flow_lang-5.12.261.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+botrun_flow_lang-5.12.261.dist-info/RECORD,,