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

flowllm/flow/gallery/mock_tool_flow.py

@@ -0,0 +1,67 @@
+from flowllm.context.service_context import C
+from flowllm.flow.base_tool_flow import BaseToolFlow
+from flowllm.op.gallery import Mock1Op, Mock2Op, Mock3Op, Mock4Op, Mock5Op, Mock6Op
+from flowllm.schema.tool_call import ToolCall, ParamAttrs
+
+
+@C.register_tool_flow()
+class MockToolFlow(BaseToolFlow):
+
+    def build_flow(self):
+        mock1_op = Mock1Op()
+        mock2_op = Mock2Op()
+        mock3_op = Mock3Op()
+        mock4_op = Mock4Op()
+        mock5_op = Mock5Op()
+        mock6_op = Mock6Op()
+
+        op = mock1_op >> ((mock4_op >> mock2_op) | mock5_op) >> (mock3_op | mock6_op)
+        return op
+
+    def build_tool_call(self) -> ToolCall:
+        return ToolCall(**{
+            "index": 0,
+            "id": "call_mock_tool_12345",
+            "type": "function",
+            "name": "mock_data_processor",
+            "description": "A mock tool that processes data through multiple operations and returns structured results",
+            "arguments": {
+                "input_data": "sample_data",
+                "processing_mode": "advanced",
+                "output_format": "json"
+            },
+            "input_schema": {
+                "input_data": ParamAttrs(
+                    type="string",
+                    description="The input data to be processed",
+                    required=True
+                ),
+                "processing_mode": ParamAttrs(
+                    type="string",
+                    description="Processing mode: basic, advanced, or expert",
+                    required=False
+                ),
+                "output_format": ParamAttrs(
+                    type="string",
+                    description="Output format: json, xml, or plain",
+                    required=False
+                )
+            },
+            "output_schema": {
+                "result": ParamAttrs(
+                    type="object",
+                    description="Processed result data",
+                    required=True
+                ),
+                "status": ParamAttrs(
+                    type="string",
+                    description="Processing status: success, warning, or error",
+                    required=True
+                ),
+                "metadata": ParamAttrs(
+                    type="object",
+                    description="Additional metadata about the processing",
+                    required=False
+                )
+            }
+        })

flowllm/flow/gallery/tavily_search_tool_flow.py

@@ -0,0 +1,30 @@
+from flowllm.context.flow_context import FlowContext
+from flowllm.context.service_context import C
+from flowllm.flow.base_tool_flow import BaseToolFlow
+from flowllm.op.search import TavilySearchOp
+from flowllm.schema.tool_call import ToolCall
+
+
+@C.register_tool_flow()
+class TavilySearchToolFlow(BaseToolFlow):
+
+    def build_flow(self):
+        return TavilySearchOp()
+
+    def build_tool_call(self) -> ToolCall:
+        return ToolCall(**{
+            "name": "web_search",
+            "description": "Use search keywords to retrieve relevant information from the internet. If there are multiple search keywords, please use each keyword separately to call this tool.",
+            "input_schema": {
+                "query": {
+                    "type": "str",
+                    "description": "search keyword",
+                    "required": True
+                }
+            }
+        })
+
+    def return_callback(self, context: FlowContext):
+        context.response.answer = context.tavily_search_result
+        return context.response
+

flowllm/flow/gallery/terminate_tool_flow.py

@@ -0,0 +1,30 @@
+from flowllm.context.flow_context import FlowContext
+from flowllm.context.service_context import C
+from flowllm.flow.base_tool_flow import BaseToolFlow
+from flowllm.op.gallery.terminate_op import TerminateOp
+from flowllm.schema.tool_call import ToolCall
+
+
+@C.register_tool_flow()
+class TerminateToolFlow(BaseToolFlow):
+
+    def build_flow(self):
+        return TerminateOp()
+
+    def build_tool_call(self) -> ToolCall:
+        return ToolCall(**{
+            "name": "terminate",
+            "description": "If you can answer the user's question based on the context, be sure to use the **terminate** tool.",
+            "input_schema": {
+                "status": {
+                    "type": "str",
+                    "description": "Please determine whether the user's question has been completed. (success / failure)",
+                    "required": True,
+                    "enum": ["success", "failure"],
+                }
+            }
+        })
+
+    def return_callback(self, context: FlowContext):
+        context.response.answer = context.terminate_answer
+        return context.response

flowllm/{flow_engine/simple_flow_engine.py → flow/parser/expression_parser.py}

@@ -1,46 +1,47 @@
 import re
 
-from loguru import logger
-
 from flowllm.context.service_context import C
-from flowllm.flow_engine.base_flow_engine import BaseFlowEngine
 from flowllm.op.base_op import BaseOp
 from flowllm.op.parallel_op import ParallelOp
 from flowllm.op.sequential_op import SequentialOp
 from flowllm.schema.service_config import OpConfig
 
 
-@C.register_flow_engine("simple")
-class SimpleFlowEngine(BaseFlowEngine):
+class ExpressionParser:
     SEQ_SYMBOL = ">>"
     PARALLEL_SYMBOL = "|"
 
     """
-    Simple flow implementation that supports parsing and executing operation expressions.
-    
+    Simple flow implementation that supports parsing operation expressions.
+
     Supports flow expressions like:
-    - "op1 >> op2" (sequential execution)
-    - "op1 | op2" (parallel execution)  
-    - "op1 >> (op2 | op3) >> op4" (mixed execution)
-    - "op1 >> (op1 | (op2 >> op3)) >> op4" (complex nested execution)
+    - "op1 >> op2" (sequential expressions)
+    - "op1 | op2" (parallel expressions)  
+    - "op1 >> (op2 | op3) >> op4" (mixed expressions)
+    - "op1 >> (op1 | (op2 >> op3)) >> op4" (complex nested expressions)
     """
 
-    def _parse_flow(self):
+    def __init__(self, flow_content: str = ""):
+        self.flow_content: str = flow_content
+        self._parsed_ops_cache = {}
+
+    def parse_flow(self):
+        self._parsed_ops_cache.clear()
         expression = re.sub(r'\s+', ' ', self.flow_content.strip())
-        self._parsed_flow = self._parse_expression(expression)
+        return self._parse_expression(expression)
 
     def _parse_expression(self, expression: str) -> BaseOp:
         """
         Parse the flow content string into executable operations.
-        
+
         Supports expressions with operators:
         - ">>" for sequential execution
         - "|" for parallel execution
         - Parentheses for grouping operations
-        
+
         Args:
             expression: The expression string to parse. If None, uses self.flow_content
-        
+
         Returns:
             BaseOp: The parsed flow as an executable operation tree
         """
@@ -78,7 +79,7 @@ class SimpleFlowEngine(BaseFlowEngine):
     def _parse_flat_expression(self, expression: str) -> BaseOp:
         """
         Parse a flat expression (no parentheses) into operation objects.
-        
+
         Args:
             expression: The flat expression string
 
@@ -98,7 +99,7 @@ class SimpleFlowEngine(BaseFlowEngine):
                 else:
                     ops.append(self._parse_parallel_expression(part))
 
-            return SequentialOp(ops=ops, flow_context=self.flow_context)
+            return SequentialOp(ops=ops)
 
         else:
             # no sequential operators, parse for parallel
@@ -107,7 +108,7 @@ class SimpleFlowEngine(BaseFlowEngine):
     def _parse_parallel_expression(self, expression: str) -> BaseOp:
         """
         Parse a parallel expression (operations separated by |).
-        
+
         Args:
             expression: The expression string
 
@@ -126,7 +127,7 @@ class SimpleFlowEngine(BaseFlowEngine):
                 else:
                     ops.append(self._create_op(part))
 
-            return ParallelOp(ops=ops, flow_context=self.flow_context)
+            return ParallelOp(ops=ops)
 
         else:
             # single operation
@@ -136,9 +137,10 @@ class SimpleFlowEngine(BaseFlowEngine):
             else:
                 return self._create_op(part)
 
-    def _create_op(self, op_name: str) -> BaseOp:
-        if op_name in self.flow_context.service_config.op:
-            op_config: OpConfig = self.flow_context.service_config.op[op_name]
+    @staticmethod
+    def _create_op(op_name: str) -> BaseOp:
+        if op_name in C.service_config.op:
+            op_config: OpConfig = C.service_config.op[op_name]
             op_cls = C.resolve_op(op_config.backend)
 
 
@@ -152,7 +154,6 @@ class SimpleFlowEngine(BaseFlowEngine):
         kwargs = {
             "name": op_name,
             "raise_exception": op_config.raise_exception,
-            "flow_context": self.flow_context,
             **op_config.params
         }
 
@@ -168,46 +169,3 @@ class SimpleFlowEngine(BaseFlowEngine):
             kwargs["vector_store"] = op_config.vector_store
 
         return op_cls(**kwargs)
-
-    def _print_flow(self):
-        """
-        Print the parsed flow structure in a readable format.
-        Allows users to visualize the execution flow on screen.
-        """
-        assert self._parsed_flow is not None, "flow_content is not parsed!"
-
-        logger.info(f"Expression: {self.flow_content}")
-        self._print_operation_tree(self._parsed_flow, indent=0)
-
-    def _print_operation_tree(self, op: BaseOp, indent: int = 0):
-        """
-        Recursively print the operation tree structure.
-        
-        Args:
-            op: The operation to print
-            indent: Current indentation level
-        """
-        prefix = "  " * indent
-        if isinstance(op, SequentialOp):
-            logger.info(f"{prefix}Sequential Execution:")
-            for i, sub_op in enumerate(op.ops):
-                logger.info(f"{prefix}  Step {i + 1}:")
-                self._print_operation_tree(sub_op, indent + 2)
-
-        elif isinstance(op, ParallelOp):
-            logger.info(f"{prefix}Parallel Execution:")
-            for i, sub_op in enumerate(op.ops):
-                logger.info(f"{prefix}  Branch {i + 1}:")
-                self._print_operation_tree(sub_op, indent + 2)
-
-        else:
-            logger.info(f"{prefix}Operation: {op.name}")
-
-    def _execute_flow(self):
-        """
-        Execute the parsed flow and return the result.
-        
-        Returns:
-            The result of executing the flow
-        """
-        return self._parsed_flow.execute()

flowllm/llm/__init__.py

@@ -1 +1,2 @@
-from flowllm.llm.openai_compatible_llm import OpenAICompatibleBaseLLM
+from .litellm_llm import LiteLLMBaseLLM
+from .openai_compatible_llm import OpenAICompatibleBaseLLM

flowllm/llm/base_llm.py

@@ -1,3 +1,4 @@
+import asyncio
 import time
 from abc import ABC
 from typing import List, Callable
@@ -28,10 +29,10 @@ class BaseLLM(BaseModel, ABC):
     stream_options: dict = Field(default={"include_usage": True}, description="Options for streaming responses")
     temperature: float = Field(default=0.0000001, description="Sampling temperature (low for deterministic outputs)")
     presence_penalty: float | None = Field(default=None, description="Presence penalty to reduce repetition")
-    
+
     # Model-specific features
     enable_thinking: bool = Field(default=False, description="Enable reasoning/thinking mode for supported models")
-    
+
     # Tool usage configuration
     tool_choice: str = Field(default=None, description="Strategy for tool selection")
     parallel_tool_calls: bool = Field(default=True, description="Allow multiple tool calls in parallel")
@@ -57,6 +58,23 @@ class BaseLLM(BaseModel, ABC):
         """
         raise NotImplementedError
 
+    async def astream_chat(self, messages: List[Message], tools: List[ToolCall] = None, **kwargs):
+        """
+        Async stream chat completions from the LLM.
+        
+        This method should yield chunks of the response as they become available,
+        allowing for real-time display of the model's output in async contexts.
+        
+        Args:
+            messages: List of conversation messages
+            tools: Optional list of tools the model can use
+            **kwargs: Additional model-specific parameters
+            
+        Yields:
+            Chunks of the streaming response with their types
+        """
+        raise NotImplementedError
+
     def _chat(self, messages: List[Message], tools: List[ToolCall] = None, enable_stream_print: bool = False,
               **kwargs) -> Message:
         """
@@ -77,6 +95,26 @@ class BaseLLM(BaseModel, ABC):
         """
         raise NotImplementedError
 
+    async def _achat(self, messages: List[Message], tools: List[ToolCall] = None, enable_stream_print: bool = False,
+                     **kwargs) -> Message:
+        """
+        Internal async method to perform a single chat completion.
+        
+        This method should be implemented by subclasses to handle the actual
+        async communication with the LLM provider. It's called by the public achat()
+        method which adds retry logic and error handling.
+        
+        Args:
+            messages: List of conversation messages
+            tools: Optional list of tools the model can use
+            enable_stream_print: Whether to print streaming response to console
+            **kwargs: Additional model-specific parameters
+            
+        Returns:
+            The complete response message from the LLM
+        """
+        raise NotImplementedError
+
     def chat(self, messages: List[Message], tools: List[ToolCall] = None, enable_stream_print: bool = False,
              callback_fn: Callable = None, default_value=None, **kwargs):
         """
@@ -107,7 +145,7 @@ class BaseLLM(BaseModel, ABC):
                                               tools=tools,
                                               enable_stream_print=enable_stream_print,
                                               **kwargs)
-                
+
                 # Apply callback function if provided
                 if callback_fn:
                     return callback_fn(message)
@@ -116,7 +154,7 @@ class BaseLLM(BaseModel, ABC):
 
             except Exception as e:
                 logger.exception(f"chat with model={self.model_name} encounter error with e={e.args}")
-                
+
                 # Exponential backoff: wait longer after each failure
                 time.sleep(1 + i)
 
@@ -128,3 +166,55 @@ class BaseLLM(BaseModel, ABC):
                         return default_value
 
         return None
+
+    async def achat(self, messages: List[Message], tools: List[ToolCall] = None, enable_stream_print: bool = False,
+                    callback_fn: Callable = None, default_value=None, **kwargs):
+        """
+        Perform an async chat completion with retry logic and error handling.
+        
+        This is the main public interface for async chat completions. It wraps the
+        internal _achat() method with robust error handling, exponential backoff,
+        and optional callback processing.
+        
+        Args:
+            messages: List of conversation messages
+            tools: Optional list of tools the model can use
+            callback_fn: Optional callback to process the response message
+            default_value: Value to return if all retries fail (when raise_exception=False)
+            enable_stream_print: Whether to print streaming response to console
+            **kwargs: Additional model-specific parameters
+            
+        Returns:
+            The response message (possibly processed by callback_fn) or default_value
+            
+        Raises:
+            Exception: If raise_exception=True and all retries fail
+        """
+        for i in range(self.max_retries):
+            try:
+                # Attempt to get response from the model
+                message: Message = await self._achat(messages=messages,
+                                                     tools=tools,
+                                                     enable_stream_print=enable_stream_print,
+                                                     **kwargs)
+
+                # Apply callback function if provided
+                if callback_fn:
+                    return callback_fn(message)
+                else:
+                    return message
+
+            except Exception as e:
+                logger.exception(f"async chat with model={self.model_name} encounter error with e={e.args}")
+
+                # Exponential backoff: wait longer after each failure
+                await asyncio.sleep(1 + i)
+
+                # Handle final retry failure
+                if i == self.max_retries - 1:
+                    if self.raise_exception:
+                        raise e
+                    else:
+                        return default_value
+
+        return None