flowllm 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

flowllm/op/code/execute_code_op.py

@@ -0,0 +1,42 @@
+import sys
+from io import StringIO
+
+from loguru import logger
+
+from flowllm.context.flow_context import FlowContext
+from flowllm.context.service_context import C
+from flowllm.op.base_op import BaseOp
+
+
+@C.register_op()
+class ExecuteCodeOp(BaseOp):
+
+    def execute(self):
+        old_stdout = sys.stdout
+        redirected_output = sys.stdout = StringIO()
+
+        try:
+            code_key: str = self.op_params.get("code_key", "code")
+            code_str: str = self.context[code_key]
+            exec(code_str)
+            code_result = redirected_output.getvalue()
+
+        except Exception as e:
+            logger.info(f"{self.name} encounter exception! error={e.args}")
+            code_result = str(e)
+
+        sys.stdout = old_stdout
+        self.context.code_result = code_result
+
+
+if __name__ == "__main__":
+    C.set_default_service_config().init_by_service_config()
+    op = ExecuteCodeOp()
+
+    context = FlowContext(code="print('Hello World')")
+    op(context=context)
+    print(context.code_result)
+
+    context.code = "print('Hello World!'"
+    op(context=context)
+    print(context.code_result)

flowllm/op/gallery/__init__.py

@@ -0,0 +1,2 @@
+from .mock_op import Mock1Op, Mock2Op, Mock3Op, Mock4Op, Mock5Op, Mock6Op
+from .terminate_op import TerminateOp

flowllm/op/gallery/mock_op.py

@@ -0,0 +1,42 @@
+import time
+
+from loguru import logger
+
+from flowllm.context.service_context import C
+from flowllm.op.base_llm_op import BaseLLMOp
+
+
+@C.register_op()
+class Mock1Op(BaseLLMOp):
+    def execute(self):
+        time.sleep(1)
+        a = self.context.a
+        b = self.context.b
+        logger.info(f"enter class={self.name}. a={a} b={b}")
+
+        self.context.response.answer = f"{self.name} {a} {b} answer=47"
+
+
+@C.register_op()
+class Mock2Op(Mock1Op):
+    ...
+
+
+@C.register_op()
+class Mock3Op(Mock1Op):
+    ...
+
+
+@C.register_op()
+class Mock4Op(Mock1Op):
+    ...
+
+
+@C.register_op()
+class Mock5Op(Mock1Op):
+    ...
+
+
+@C.register_op()
+class Mock6Op(Mock1Op):
+    ...

flowllm/op/gallery/terminate_op.py

@@ -0,0 +1,29 @@
+from flowllm.context.service_context import C
+from flowllm.op.base_op import BaseOp
+
+
+@C.register_op()
+class TerminateOp(BaseOp):
+
+    def execute(self):
+        # Get status from context
+        status = self.context.status
+        assert status in ["success", "failure"], f"Invalid status: {status}"
+        self.context.terminate_answer = f"The interaction has been completed with status: {status}"
+
+
+if __name__ == "__main__":
+    from flowllm.context.flow_context import FlowContext
+
+    C.set_default_service_config().init_by_service_config()
+
+    # Test success termination
+    op = TerminateOp()
+    context = FlowContext(status="success")
+    result = op(context=context)
+    print(f"Result: {context.terminate_answer}")
+
+    # Test failure termination
+    context.status = "failure"
+    op(context=context)
+    print(f"Result: {context.terminate_answer}")

flowllm/op/parallel_op.py

@@ -0,0 +1,23 @@
+from typing import List
+
+from flowllm.op.base_op import BaseOp
+
+
+class ParallelOp(BaseOp):
+
+    def __init__(self, ops: List[BaseOp], **kwargs):
+        super().__init__(**kwargs)
+        self.ops = ops
+
+    def execute(self):
+        for op in self.ops:
+            self.submit_task(op.__call__, context=self.context)
+
+        self.join_task(task_desc="parallel execution")
+
+    def __or__(self, op: BaseOp):
+        if isinstance(op, ParallelOp):
+            self.ops.extend(op.ops)
+        else:
+            self.ops.append(op)
+        return self

flowllm/op/search/__init__.py

@@ -0,0 +1,3 @@
+from .dashscope_deep_research_op import DashscopeDeepResearchOp
+from .dashscope_search_op import DashscopeSearchOp
+from .tavily_search_op import TavilySearchOp

flowllm/op/search/dashscope_deep_research_op.py

@@ -0,0 +1,260 @@
+import os
+
+import dashscope
+from loguru import logger
+
+from flowllm.context.flow_context import FlowContext
+from flowllm.context.service_context import C
+from flowllm.op.base_llm_op import BaseLLMOp
+from flowllm.storage.cache.data_cache import DataCache
+
+
+@C.register_op()
+class DashscopeDeepResearchOp(BaseLLMOp):
+    file_path: str = __file__
+
+    """
+    Dashscope deep research operation using Alibaba's Qwen-deep-research model.
+    
+    This operation performs deep research using Dashscope's Generation API with the 
+    qwen-deep-research model. It handles the multi-phase research process including
+    model questioning, web research, and result generation.
+    """
+
+    def __init__(self,
+                 model: str = "qwen-deep-research",
+                 enable_print: bool = True,
+                 enable_cache: bool = True,
+                 cache_path: str = "./dashscope_deep_research_cache",
+                 cache_expire_hours: float = 24,
+                 max_retries: int = 3,
+                 return_only_content: bool = True,
+                 **kwargs):
+        super().__init__(**kwargs)
+
+        self.model = model
+        self.enable_print = enable_print
+        self.enable_cache = enable_cache
+        self.cache_expire_hours = cache_expire_hours
+        self.max_retries = max_retries
+        self.return_only_content = return_only_content
+
+        # Ensure API key is available
+        self.api_key = os.getenv("FLOW_DASHSCOPE_API_KEY")
+        self.cache = DataCache(cache_path) if self.enable_cache else None
+
+    def process_responses(self, responses, step_name):
+        """Process streaming responses from the deep research model"""
+        current_phase = None
+        phase_content = ""
+        research_goal = ""
+        web_sites = []
+        keepalive_shown = False  # 标记是否已经显示过KeepAlive提示
+
+        for response in responses:
+            # 检查响应状态码
+            if hasattr(response, 'status_code') and response.status_code != 200:
+                logger.warning(f"HTTP返回码：{response.status_code}")
+                if hasattr(response, 'code'):
+                    logger.warning(f"错误码：{response.code}")
+                if hasattr(response, 'message'):
+                    logger.warning(f"错误信息：{response.message}")
+                continue
+
+            if hasattr(response, 'output') and response.output:
+                message = response.output.get('message', {})
+                phase = message.get('phase')
+                content = message.get('content', '')
+                status = message.get('status')
+                extra = message.get('extra', {})
+
+                # 阶段变化检测
+                if phase != current_phase:
+                    if current_phase and phase_content:
+                        # 根据阶段名称和步骤名称来显示不同的完成描述
+                        if step_name == "第一步：模型反问确认" and current_phase == "answer":
+                            logger.info("模型反问阶段完成")
+                        else:
+                            logger.info(f"{current_phase} 阶段完成")
+                    current_phase = phase
+                    phase_content = ""
+                    keepalive_shown = False  # 重置KeepAlive提示标记
+
+                    # 根据阶段名称和步骤名称来显示不同的描述
+                    if step_name == "第一步：模型反问确认" and phase == "answer":
+                        logger.info("进入模型反问阶段")
+                    else:
+                        logger.info(f"进入 {phase} 阶段")
+
+                # 处理WebResearch阶段的特殊信息
+                if phase == "WebResearch":
+                    if extra.get('deep_research', {}).get('research'):
+                        research_info = extra['deep_research']['research']
+
+                        # 处理streamingQueries状态
+                        if status == "streamingQueries":
+                            if 'researchGoal' in research_info:
+                                goal = research_info['researchGoal']
+                                if goal:
+                                    research_goal += goal
+                                    if self.enable_print:
+                                        print(f"   研究目标: {goal}", end='', flush=True)
+
+                        # 处理streamingWebResult状态
+                        elif status == "streamingWebResult":
+                            if 'webSites' in research_info:
+                                sites = research_info['webSites']
+                                if sites and sites != web_sites:  # 避免重复显示
+                                    web_sites = sites
+                                    if self.enable_print:
+                                        print(f"   找到 {len(sites)} 个相关网站:")
+                                        for i, site in enumerate(sites, 1):
+                                            print(f"     {i}. {site.get('title', '无标题')}")
+                                            print(f"        描述: {site.get('description', '无描述')[:100]}...")
+                                            print(f"        URL: {site.get('url', '无链接')}")
+                                            if site.get('favicon'):
+                                                print(f"        图标: {site['favicon']}")
+                                            print()
+
+                        # 处理WebResultFinished状态
+                        elif status == "WebResultFinished":
+                            if self.enable_print:
+                                print(f"   网络搜索完成，共找到 {len(web_sites)} 个参考信息源")
+                                if research_goal:
+                                    print(f"   研究目标: {research_goal}")
+
+                # 累积内容并显示
+                if content:
+                    phase_content += content
+                    # 实时显示内容
+                    if self.enable_print:
+                        print(content, end='', flush=True)
+
+                # 显示阶段状态变化
+                if status and status != "typing":
+                    if self.enable_print:
+                        print(f"   状态: {status}")
+
+                    # 显示状态说明
+                    if status == "streamingQueries":
+                        if self.enable_print:
+                            print("   → 正在生成研究目标和搜索查询（WebResearch阶段）")
+                    elif status == "streamingWebResult":
+                        if self.enable_print:
+                            print("   → 正在执行搜索、网页阅读和代码执行（WebResearch阶段）")
+                    elif status == "WebResultFinished":
+                        if self.enable_print:
+                            print("   → 网络搜索阶段完成（WebResearch阶段）")
+
+                # 当状态为finished时，显示token消耗情况
+                if status == "finished":
+                    if hasattr(response, 'usage') and response.usage:
+                        usage = response.usage
+                        if self.enable_print:
+                            print(f"    Token消耗统计:")
+                            print(f"      输入tokens: {usage.get('input_tokens', 0)}")
+                            print(f"      输出tokens: {usage.get('output_tokens', 0)}")
+                            print(f"      请求ID: {response.get('request_id', '未知')}")
+
+                if phase == "KeepAlive":
+                    # 只在第一次进入KeepAlive阶段时显示提示
+                    if not keepalive_shown:
+                        if self.enable_print:
+                            print("当前步骤已经完成，准备开始下一步骤工作")
+                        keepalive_shown = True
+                    continue
+
+        if current_phase and phase_content:
+            if step_name == "第一步：模型反问确认" and current_phase == "answer":
+                logger.info("模型反问阶段完成")
+            else:
+                logger.info(f"{current_phase} 阶段完成")
+
+        return phase_content
+
+    def call_deep_research_model(self, messages, step_name):
+        """Call the deep research model with the given messages"""
+        if self.enable_print:
+            print(f"\n=== {step_name} ===")
+
+        try:
+            responses = dashscope.Generation.call(
+                api_key=self.api_key,
+                model=self.model,
+                messages=messages,
+                # qwen-deep-research模型目前仅支持流式输出
+                stream=True
+                # incremental_output=True 使用增量输出请添加此参数
+            )
+
+            return self.process_responses(responses, step_name)
+
+        except Exception as e:
+            logger.error(f"调用API时发生错误: {e}")
+            return ""
+
+    def execute(self):
+        """Execute the Dashscope deep research operation"""
+        # Get query from context
+        query = self.context.query
+
+        # Check cache first
+        if self.enable_cache and self.cache:
+            cached_result = self.cache.load(query)
+            if cached_result:
+                if self.return_only_content:
+                    self.context.dashscope_deep_research_result = cached_result.get("content", "")
+                else:
+                    self.context.dashscope_deep_research_result = cached_result
+                return
+
+        # 第一步：模型反问确认
+        # 模型会分析用户问题，提出细化问题来明确研究方向
+        messages = [{'role': 'user', 'content': query}]
+        step1_content = self.call_deep_research_model(messages, "第一步：模型反问确认")
+
+        # 第二步：深入研究
+        # 基于第一步的反问内容，模型会执行完整的研究流程
+        messages = [
+            {'role': 'user', 'content': query},
+            {'role': 'assistant', 'content': step1_content},  # 包含模型的反问内容
+            {'role': 'user', 'content': '帮我生成完整且逻辑性的报告'}
+        ]
+
+        result_content = self.call_deep_research_model(messages, "第二步：深入研究")
+
+        if self.enable_print:
+            print(result_content)
+            print("\n 研究完成！")
+
+        # Prepare final result
+        final_result = {
+            "query": query,
+            "step1_content": step1_content,
+            "final_result": result_content,
+            "model": self.model
+        }
+
+        # Cache the result if enabled
+        if self.enable_cache and self.cache:
+            self.cache.save(query, final_result, expire_hours=self.cache_expire_hours)
+
+        # Set context
+        if self.return_only_content:
+            self.context.dashscope_deep_research_result = result_content
+        else:
+            self.context.dashscope_deep_research_result = final_result
+
+
+def main():
+    C.set_default_service_config().init_by_service_config()
+
+    op = DashscopeDeepResearchOp(enable_print=True, enable_cache=True)
+
+    context = FlowContext(query="中国电解铝行业值得投资吗，有哪些值得投资的标的，各个标的之间需要对比优劣势")
+    op(context=context)
+    print(context.dashscope_deep_research_result)
+
+
+if __name__ == "__main__":
+    main()

flowllm/op/search/dashscope_search_op.py

@@ -0,0 +1,179 @@
+import os
+import time
+from typing import Dict, Any, List
+
+import dashscope
+from loguru import logger
+
+from flowllm.context.flow_context import FlowContext
+from flowllm.context.service_context import C
+from flowllm.op.base_llm_op import BaseLLMOp
+from flowllm.storage.cache.data_cache import DataCache
+
+
+@C.register_op()
+class DashscopeSearchOp(BaseLLMOp):
+    file_path: str = __file__
+
+    """
+    Dashscope search operation using Alibaba's Qwen model with search capabilities.
+
+    This operation performs web search using Dashscope's Generation API with search enabled.
+    It extracts search results and provides formatted responses with citations.
+    """
+
+    def __init__(self,
+                 model: str = "qwen-plus",
+                 enable_print: bool = True,
+                 enable_cache: bool = False,
+                 cache_path: str = "./dashscope_search_cache",
+                 cache_expire_hours: float = 0.1,
+                 max_retries: int = 3,
+                 search_strategy: str = "max",
+                 return_only_content: bool = True,
+                 enable_role_prompt: bool = True,
+                 **kwargs):
+        super().__init__(**kwargs)
+
+        self.model = model
+        self.enable_print = enable_print
+        self.enable_cache = enable_cache
+        self.cache_expire_hours = cache_expire_hours
+        self.max_retries = max_retries
+        self.search_strategy = search_strategy
+        self.return_only_content = return_only_content
+        self.enable_role_prompt = enable_role_prompt
+
+        # Ensure API key is available
+        self.api_key = os.getenv("FLOW_DASHSCOPE_API_KEY")
+        self.cache = DataCache(cache_path) if self.enable_cache else None
+
+    @staticmethod
+    def format_search_results(search_results: List[Dict[str, Any]]) -> str:
+        """Format search results for display"""
+        formatted_results = ["=" * 20 + " Search Results " + "=" * 20]
+
+        for web in search_results:
+            formatted_results.append(f"[{web['index']}]: [{web['title']}]({web['url']})")
+
+        return "\n".join(formatted_results)
+
+    def post_process(self, response_data: dict) -> dict:
+        """Post-process the response and optionally print results"""
+        if self.enable_print:
+            # Print search information
+            if "search_results" in response_data:
+                search_info = self.format_search_results(response_data["search_results"])
+                logger.info(f"Search Information:\n{search_info}")
+
+            # Print response content
+            if "response_content" in response_data:
+                logger.info("=" * 20 + " Response Content " + "=" * 20)
+                logger.info(response_data["response_content"])
+
+        return response_data
+
+    def execute(self):
+        """Execute the Dashscope search operation"""
+        # Get query from context - support multiple parameter names
+        query = self.context.query
+
+        # Check cache first
+        if self.enable_cache and self.cache:
+            cached_result = self.cache.load(query)
+            if cached_result:
+                result = self.post_process(cached_result)
+                if self.return_only_content:
+                    self.context.dashscope_search_result = result["response_content"]
+                else:
+                    self.context.dashscope_search_result = result
+
+                return
+
+        if self.enable_role_prompt:
+            user_query = self.prompt_format(prompt_name="role_prompt", query=query)
+        else:
+            user_query = query
+        messages: list = [{"role": "user", "content": user_query}]
+
+        # Retry logic for API calls
+        for attempt in range(self.max_retries):
+            try:
+                # Call Dashscope Generation API with search enabled
+                response = dashscope.Generation.call(
+                    api_key=self.api_key,
+                    model=self.model,
+                    messages=messages,
+                    enable_search=True,  # Enable web search
+                    search_options={
+                        "forced_search": True,  # Force web search
+                        "enable_source": True,  # Include search source information
+                        "enable_citation": False,  # Enable citation markers
+                        "search_strategy": self.search_strategy,  # Search strategy
+                    },
+                    result_format="message",
+                )
+
+                # Extract search results and response content
+                search_results = []
+                response_content = ""
+
+                if hasattr(response, 'output') and response.output:
+                    # Extract search information
+                    if hasattr(response.output, 'search_info') and response.output.search_info:
+                        search_results = response.output.search_info.get("search_results", [])
+
+                    # Extract response content
+                    if (hasattr(response.output, 'choices') and
+                            response.output.choices and
+                            len(response.output.choices) > 0):
+                        response_content = response.output.choices[0].message.content
+
+                # Prepare final result
+                final_result = {
+                    "query": query,
+                    "search_results": search_results,
+                    "response_content": response_content,
+                    "model": self.model,
+                    "search_strategy": self.search_strategy
+                }
+
+                # Cache the result if enabled
+                if self.enable_cache and self.cache:
+                    self.cache.save(query, final_result, expire_hours=self.cache_expire_hours)
+
+                # Post-process and set context
+                result = self.post_process(final_result)
+                if self.return_only_content:
+                    self.context.dashscope_search_result = result["response_content"]
+                else:
+                    self.context.dashscope_search_result = result
+
+                return
+
+            except Exception as e:
+                logger.warning(f"Dashscope search attempt {attempt + 1} failed for query='{query}': {e}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(attempt + 1)  # Exponential backoff
+                else:
+                    logger.error(f"All {self.max_retries} attempts failed for Dashscope search")
+
+        self.context.dashscope_search_result = "dashscope_search failed"
+
+
+def main():
+    from flowllm.utils.common_utils import load_env
+
+    load_env()
+
+    C.set_default_service_config().init_by_service_config()
+
+    op = DashscopeSearchOp(enable_print=True, enable_cache=False)
+
+    context = FlowContext(query="杭州明天天气")
+    op(context=context)
+    print(context.dashscope_search_result)
+
+
+if __name__ == "__main__":
+    main()

flowllm/op/search/dashscope_search_prompt.yaml

@@ -0,0 +1,13 @@
+role_prompt: |
+  # user's question
+  {query}
+
+  # task
+  Extract the original content related to the user's query directly from the context, maintain accuracy, and avoid excessive processing.
+
+role_prompt_zh: |
+  # 用户问题
+  {query}
+
+  # task
+  直接从上下文中提取与用户问题相关的原始内容，保持准确性，避免过度处理。