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

{llmflow → flowllm}/embedding_model/openai_compatible_embedding_model.py

@@ -1,15 +1,14 @@
 import os
 from typing import Literal, List
 
-from dotenv import load_dotenv
 from openai import OpenAI
 from pydantic import Field, PrivateAttr, model_validator
 
-from llmflow.embedding_model import EMBEDDING_MODEL_REGISTRY
-from llmflow.embedding_model.base_embedding_model import BaseEmbeddingModel
+from flowllm.context.service_context import C
+from flowllm.embedding_model.base_embedding_model import BaseEmbeddingModel
 
 
-@EMBEDDING_MODEL_REGISTRY.register("openai_compatible")
+@C.register_embedding_model("openai_compatible")
 class OpenAICompatibleEmbeddingModel(BaseEmbeddingModel):
     """
     OpenAI-compatible embedding model implementation.
@@ -19,9 +18,9 @@ class OpenAICompatibleEmbeddingModel(BaseEmbeddingModel):
     other services that follow the same interface.
     """
     # API configuration fields
-    api_key: str = Field(default_factory=lambda: os.getenv("EMBEDDING_API_KEY"),
+    api_key: str = Field(default_factory=lambda: os.getenv("FLOW_EMBEDDING_API_KEY"),
                          description="API key for authentication")
-    base_url: str = Field(default_factory=lambda: os.getenv("EMBEDDING_BASE_URL"),
+    base_url: str = Field(default_factory=lambda: os.getenv("FLOW_EMBEDDING_BASE_URL"),
                           description="Base URL for the API endpoint")
     model_name: str = Field(default="", description="Name of the embedding model to use")
     dimensions: int = Field(default=1024, description="Dimensionality of the embedding vectors")
@@ -81,7 +80,9 @@ class OpenAICompatibleEmbeddingModel(BaseEmbeddingModel):
 
 
 def main():
-    load_dotenv()
+    from flowllm.utils.common_utils import load_env
+
+    load_env()
     model = OpenAICompatibleEmbeddingModel(dimensions=64, model_name="text-embedding-v4")
     res1 = model.get_embeddings(
         "The clothes are of good quality and look good, definitely worth the wait. I love them.")
@@ -92,4 +93,3 @@ def main():
 
 if __name__ == "__main__":
     main()
-    # launch with: python -m llmflow.model.openai_compatible_embedding_model

flowllm/flow_engine/__init__.py

@@ -0,0 +1 @@
+from flowllm.flow_engine import simple_flow_engine

flowllm/flow_engine/base_flow_engine.py

@@ -0,0 +1,34 @@
+from abc import ABC
+from typing import Optional
+
+from flowllm.context.flow_context import FlowContext
+from flowllm.op.base_op import BaseOp
+from flowllm.utils.timer import timer
+
+
+class BaseFlowEngine(ABC):
+
+    def __init__(self, flow_name: str, flow_content: str, flow_context: FlowContext):
+        self.flow_name: str = flow_name
+        self.flow_content: str = flow_content
+        self.flow_context: FlowContext = flow_context
+
+        self._parsed_flow: Optional[BaseOp] = None
+        self._parsed_ops_cache = {}
+
+    def _parse_flow(self):
+        raise NotImplementedError
+
+    def _create_op(self, op_name: str):
+        raise NotImplementedError
+
+    def _print_flow(self):
+        raise NotImplementedError
+
+    def _execute_flow(self):
+        raise NotImplementedError
+
+    def __call__(self):
+        self._parse_flow()
+        self._print_flow()
+        return self._execute_flow()

flowllm/flow_engine/simple_flow_engine.py

@@ -0,0 +1,213 @@
+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):
+    SEQ_SYMBOL = ">>"
+    PARALLEL_SYMBOL = "|"
+
+    """
+    Simple flow implementation that supports parsing and executing 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)
+    """
+
+    def _parse_flow(self):
+        expression = re.sub(r'\s+', ' ', self.flow_content.strip())
+        self._parsed_flow = 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
+        """
+        # handle parentheses by finding and replacing innermost groups
+        while '(' in expression:
+            # Find the innermost parentheses
+            start = -1
+            for i, char in enumerate(expression):
+                if char == '(':
+                    start = i
+                elif char == ')':
+                    if start == -1:
+                        raise ValueError(f"mismatched parentheses in expression: {expression}")
+
+                    # extract and parse the inner expression
+                    inner_expr = expression[start + 1:i]
+                    inner_result = self._parse_expression(inner_expr)
+
+                    # create a placeholder for the parsed inner expression
+                    placeholder = f"__PARSED_OP_{len(self._parsed_ops_cache)}__"
+
+                    # store the parsed operation for later retrieval
+                    self._parsed_ops_cache[placeholder] = inner_result
+
+                    # Replace the parentheses group with placeholder
+                    expression = expression[:start] + placeholder + expression[i + 1:]
+                    break
+            else:
+                if start != -1:
+                    raise ValueError(f"mismatched parentheses in expression: {expression}")
+
+        # Parse the expression without parentheses
+        return self._parse_flat_expression(expression)
+
+    def _parse_flat_expression(self, expression: str) -> BaseOp:
+        """
+        Parse a flat expression (no parentheses) into operation objects.
+        
+        Args:
+            expression: The flat expression string
+
+        Returns:
+            BaseOp: The parsed operation tree
+        """
+        # split by '>>' first (sequential has higher precedence)
+        sequential_parts = [part.strip() for part in expression.split(self.SEQ_SYMBOL)]
+
+        if len(sequential_parts) > 1:
+            # parse each part and create sequential operation
+            ops = []
+            for part in sequential_parts:
+                part = part.strip()
+                if part in self._parsed_ops_cache:
+                    ops.append(self._parsed_ops_cache[part])
+                else:
+                    ops.append(self._parse_parallel_expression(part))
+
+            return SequentialOp(ops=ops, flow_context=self.flow_context)
+
+        else:
+            # no sequential operators, parse for parallel
+            return self._parse_parallel_expression(expression)
+
+    def _parse_parallel_expression(self, expression: str) -> BaseOp:
+        """
+        Parse a parallel expression (operations separated by |).
+        
+        Args:
+            expression: The expression string
+
+        Returns:
+            BaseOp: The parsed operation (single op or parallel op)
+        """
+        parallel_parts = [part.strip() for part in expression.split(self.PARALLEL_SYMBOL)]
+
+        if len(parallel_parts) > 1:
+            # create parallel operation
+            ops = []
+            for part in parallel_parts:
+                part = part.strip()
+                if part in self._parsed_ops_cache:
+                    ops.append(self._parsed_ops_cache[part])
+                else:
+                    ops.append(self._create_op(part))
+
+            return ParallelOp(ops=ops, flow_context=self.flow_context)
+
+        else:
+            # single operation
+            part = expression.strip()
+            if part in self._parsed_ops_cache:
+                return self._parsed_ops_cache[part]
+            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]
+            op_cls = C.resolve_op(op_config.backend)
+
+
+        elif op_name in C.registry_dict["op"]:
+            op_config: OpConfig = OpConfig()
+            op_cls = C.resolve_op(op_name)
+
+        else:
+            raise ValueError(f"op='{op_name}' is not registered!")
+
+        kwargs = {
+            "name": op_name,
+            "raise_exception": op_config.raise_exception,
+            "flow_context": self.flow_context,
+            **op_config.params
+        }
+
+        if op_config.language:
+            kwargs["language"] = op_config.language
+        if op_config.prompt_path:
+            kwargs["prompt_path"] = op_config.prompt_path
+        if op_config.llm:
+            kwargs["llm"] = op_config.llm
+        if op_config.embedding_model:
+            kwargs["embedding_model"] = op_config.embedding_model
+        if op_config.vector_store:
+            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

@@ -0,0 +1 @@
+from flowllm.llm.openai_compatible_llm import OpenAICompatibleBaseLLM

{llmflow → flowllm}/llm/base_llm.py

@@ -1,12 +1,12 @@
 import time
 from abc import ABC
-from typing import List, Literal, Callable
+from typing import List, Callable
 
 from loguru import logger
 from pydantic import Field, BaseModel
 
-from llmflow.schema.message import Message
-from llmflow.tool.base_tool import BaseTool
+from flowllm.schema.message import Message
+from flowllm.schema.tool_call import ToolCall
 
 
 class BaseLLM(BaseModel, ABC):
@@ -30,17 +30,17 @@ class BaseLLM(BaseModel, ABC):
     presence_penalty: float | None = Field(default=None, description="Presence penalty to reduce repetition")
     
     # Model-specific features
-    enable_thinking: bool = Field(default=True, description="Enable reasoning/thinking mode for supported models")
+    enable_thinking: bool = Field(default=False, description="Enable reasoning/thinking mode for supported models")
     
     # Tool usage configuration
-    tool_choice: Literal["none", "auto", "required"] = Field(default="auto", description="Strategy for tool selection")
+    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")
 
     # Error handling and reliability
     max_retries: int = Field(default=5, description="Maximum number of retry attempts on failure")
     raise_exception: bool = Field(default=False, description="Whether to raise exceptions or return default values")
 
-    def stream_chat(self, messages: List[Message], tools: List[BaseTool] = None, **kwargs):
+    def stream_chat(self, messages: List[Message], tools: List[ToolCall] = None, **kwargs):
         """
         Stream chat completions from the LLM.
         
@@ -57,21 +57,8 @@ class BaseLLM(BaseModel, ABC):
         """
         raise NotImplementedError
 
-    def stream_print(self, messages: List[Message], tools: List[BaseTool] = None, **kwargs):
-        """
-        Stream chat completions and print them to console in real-time.
-        
-        This is a convenience method for debugging and interactive use,
-        combining streaming with formatted console output.
-        
-        Args:
-            messages: List of conversation messages
-            tools: Optional list of tools the model can use
-            **kwargs: Additional model-specific parameters
-        """
-        raise NotImplementedError
-
-    def _chat(self, messages: List[Message], tools: List[BaseTool] = None, **kwargs) -> Message:
+    def _chat(self, messages: List[Message], tools: List[ToolCall] = None, enable_stream_print: bool = False,
+              **kwargs) -> Message:
         """
         Internal method to perform a single chat completion.
         
@@ -82,6 +69,7 @@ class BaseLLM(BaseModel, ABC):
         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:
@@ -89,8 +77,8 @@ class BaseLLM(BaseModel, ABC):
         """
         raise NotImplementedError
 
-    def chat(self, messages: List[Message], tools: List[BaseTool] = None, callback_fn: Callable = None,
-             default_value=None, **kwargs):
+    def chat(self, messages: List[Message], tools: List[ToolCall] = None, enable_stream_print: bool = False,
+             callback_fn: Callable = None, default_value=None, **kwargs):
         """
         Perform a chat completion with retry logic and error handling.
         
@@ -103,6 +91,7 @@ class BaseLLM(BaseModel, ABC):
             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:
@@ -114,7 +103,10 @@ class BaseLLM(BaseModel, ABC):
         for i in range(self.max_retries):
             try:
                 # Attempt to get response from the model
-                message: Message = self._chat(messages, tools, **kwargs)
+                message: Message = self._chat(messages=messages,
+                                              tools=tools,
+                                              enable_stream_print=enable_stream_print,
+                                              **kwargs)
                 
                 # Apply callback function if provided
                 if callback_fn:

{llmflow → flowllm}/llm/openai_compatible_llm.py

@@ -1,21 +1,20 @@
 import os
-from typing import List
+from typing import List, Dict
 
-from dotenv import load_dotenv
 from loguru import logger
 from openai import OpenAI
 from openai.types import CompletionUsage
 from pydantic import Field, PrivateAttr, model_validator
 
-from llmflow.enumeration.chunk_enum import ChunkEnum
-from llmflow.enumeration.role import Role
-from llmflow.llm import LLM_REGISTRY
-from llmflow.llm.base_llm import BaseLLM
-from llmflow.schema.message import Message, ToolCall
-from llmflow.tool.base_tool import BaseTool
+from flowllm.context.service_context import C
+from flowllm.enumeration.chunk_enum import ChunkEnum
+from flowllm.enumeration.role import Role
+from flowllm.llm.base_llm import BaseLLM
+from flowllm.schema.message import Message
+from flowllm.schema.tool_call import ToolCall
 
 
-@LLM_REGISTRY.register("openai_compatible")
+@C.register_llm("openai_compatible")
 class OpenAICompatibleBaseLLM(BaseLLM):
     """
     OpenAI-compatible LLM implementation supporting streaming and tool calls.
@@ -29,8 +28,9 @@ class OpenAICompatibleBaseLLM(BaseLLM):
     """
 
     # API configuration
-    api_key: str = Field(default_factory=lambda: os.getenv("LLM_API_KEY"), description="API key for authentication")
-    base_url: str = Field(default_factory=lambda: os.getenv("LLM_BASE_URL"),
+    api_key: str = Field(default_factory=lambda: os.getenv("FLOW_LLM_API_KEY"),
+                         description="API key for authentication")
+    base_url: str = Field(default_factory=lambda: os.getenv("FLOW_LLM_BASE_URL"),
                           description="Base URL for the API endpoint")
     _client: OpenAI = PrivateAttr()
 
@@ -48,7 +48,7 @@ class OpenAICompatibleBaseLLM(BaseLLM):
         self._client = OpenAI(api_key=self.api_key, base_url=self.base_url)
         return self
 
-    def stream_chat(self, messages: List[Message], tools: List[BaseTool] = None, **kwargs):
+    def stream_chat(self, messages: List[Message], tools: List[ToolCall] = None, **kwargs):
         """
         Stream chat completions from OpenAI-compatible API.
         
@@ -69,7 +69,10 @@ class OpenAICompatibleBaseLLM(BaseLLM):
         """
         for i in range(self.max_retries):
             try:
-                # Create streaming completion request
+                extra_body = {}
+                if self.enable_thinking:
+                    extra_body["enable_thinking"] = True  # qwen3 params
+
                 completion = self._client.chat.completions.create(
                     model=self.model_name,
                     messages=[x.simple_dump() for x in messages],
@@ -78,14 +81,13 @@ class OpenAICompatibleBaseLLM(BaseLLM):
                     stream=True,
                     stream_options=self.stream_options,
                     temperature=self.temperature,
-                    extra_body={"enable_thinking": self.enable_thinking},  # Enable reasoning mode
-                    tools=[x.simple_dump() for x in tools] if tools else None,
-                    tool_choice=self.tool_choice,
+                    extra_body=extra_body,
+                    tools=[x.simple_input_dump() for x in tools] if tools else None,
                     parallel_tool_calls=self.parallel_tool_calls)
 
                 # Initialize tool call tracking
-                ret_tools = []  # Accumulate tool calls across chunks
-                is_answering = False  # Track when model starts answering
+                ret_tools: List[ToolCall] = []  # Accumulate tool calls across chunks
+                is_answering: bool = False  # Track when model starts answering
 
                 # Process each chunk in the streaming response
                 for chunk in completion:
@@ -130,7 +132,7 @@ class OpenAICompatibleBaseLLM(BaseLLM):
 
                 # Yield completed tool calls after streaming finishes
                 if ret_tools:
-                    tool_dict = {x.name: x for x in tools} if tools else {}
+                    tool_dict: Dict[str, ToolCall] = {x.name: x for x in tools} if tools else {}
                     for tool in ret_tools:
                         # Only yield tool calls that correspond to available tools
                         if tool.name not in tool_dict:
@@ -138,7 +140,7 @@ class OpenAICompatibleBaseLLM(BaseLLM):
 
                         yield tool, ChunkEnum.TOOL
 
-                return  # Success - exit retry loop
+                return
 
             except Exception as e:
                 logger.exception(f"stream chat with model={self.model_name} encounter error with e={e.args}")
@@ -149,7 +151,8 @@ class OpenAICompatibleBaseLLM(BaseLLM):
                 else:
                     yield e.args, ChunkEnum.ERROR
 
-    def _chat(self, messages: List[Message], tools: List[BaseTool] = None, **kwargs) -> Message:
+    def _chat(self, messages: List[Message], tools: List[ToolCall] = None, enable_stream_print: bool = False,
+              **kwargs) -> Message:
         """
         Perform a complete chat completion by aggregating streaming chunks.
         
@@ -160,28 +163,60 @@ class OpenAICompatibleBaseLLM(BaseLLM):
         Args:
             messages: List of conversation messages
             tools: Optional list of tools available to the model
+            enable_stream_print: Whether to print streaming response to console
             **kwargs: Additional parameters
             
         Returns:
             Complete Message with all content aggregated
         """
-        # Initialize content accumulators
+
+        enter_think = False  # Whether we've started printing thinking content
+        enter_answer = False  # Whether we've started printing answer content
         reasoning_content = ""  # Model's internal reasoning
         answer_content = ""  # Final response content
         tool_calls = []  # List of tool calls to execute
 
         # Consume streaming response and aggregate chunks by type
         for chunk, chunk_enum in self.stream_chat(messages, tools, **kwargs):
-            if chunk_enum is ChunkEnum.THINK:
+            if chunk_enum is ChunkEnum.USAGE:
+                # Display token usage statistics
+                if enable_stream_print:
+                    if isinstance(chunk, CompletionUsage):
+                        print(f"\n<usage>{chunk.model_dump_json(indent=2)}</usage>")
+                    else:
+                        print(f"\n<usage>{chunk}</usage>")
+
+            elif chunk_enum is ChunkEnum.THINK:
+                if enable_stream_print:
+                    # Format thinking/reasoning content
+                    if not enter_think:
+                        enter_think = True
+                        print("<think>\n", end="")
+                    print(chunk, end="")
+
                 reasoning_content += chunk
 
             elif chunk_enum is ChunkEnum.ANSWER:
+                if enable_stream_print:
+                    if not enter_answer:
+                        enter_answer = True
+                        # Close thinking section if we were in it
+                        if enter_think:
+                            print("\n</think>")
+                    print(chunk, end="")
+
                 answer_content += chunk
 
             elif chunk_enum is ChunkEnum.TOOL:
+                if enable_stream_print:
+                    print(f"\n<tool>{chunk.model_dump_json()}</tool>", end="")
+
                 tool_calls.append(chunk)
 
-            # Note: USAGE and ERROR chunks are ignored in non-streaming mode
+            elif chunk_enum is ChunkEnum.ERROR:
+                if enable_stream_print:
+                    # Display error information
+                    print(f"\n<error>{chunk}</error>", end="")
 
         # Construct complete response message
         return Message(role=Role.ASSISTANT,
@@ -189,95 +224,16 @@ class OpenAICompatibleBaseLLM(BaseLLM):
                        content=answer_content,
                        tool_calls=tool_calls)
 
-    def stream_print(self, messages: List[Message], tools: List[BaseTool] = None, **kwargs):
-        """
-        Stream chat completions with formatted console output.
-        
-        This method provides a real-time view of the model's response,
-        with different formatting for different types of content:
-        - Thinking content is wrapped in <think></think> tags
-        - Answer content is printed directly
-        - Tool calls are formatted as JSON
-        - Usage statistics and errors are clearly marked
-        
-        Args:
-            messages: List of conversation messages
-            tools: Optional list of tools available to the model
-            **kwargs: Additional parameters
-        """
-        # Track which sections we've entered for proper formatting
-        enter_think = False  # Whether we've started printing thinking content
-        enter_answer = False  # Whether we've started printing answer content
-
-        # Process each streaming chunk with appropriate formatting
-        for chunk, chunk_enum in self.stream_chat(messages, tools, **kwargs):
-            if chunk_enum is ChunkEnum.USAGE:
-                # Display token usage statistics
-                if isinstance(chunk, CompletionUsage):
-                    print(f"\n<usage>{chunk.model_dump_json(indent=2)}</usage>")
-                else:
-                    print(f"\n<usage>{chunk}</usage>")
-
-            elif chunk_enum is ChunkEnum.THINK:
-                # Format thinking/reasoning content
-                if not enter_think:
-                    enter_think = True
-                    print("<think>\n", end="")
-                print(chunk, end="")
-
-            elif chunk_enum is ChunkEnum.ANSWER:
-                # Format regular answer content
-                if not enter_answer:
-                    enter_answer = True
-                    # Close thinking section if we were in it
-                    if enter_think:
-                        print("\n</think>")
-                print(chunk, end="")
-
-            elif chunk_enum is ChunkEnum.TOOL:
-                # Format tool calls as structured JSON
-                assert isinstance(chunk, ToolCall)
-                print(f"\n<tool>{chunk.model_dump_json(indent=2)}</tool>", end="")
-
-            elif chunk_enum is ChunkEnum.ERROR:
-                # Display error information
-                print(f"\n<error>{chunk}</error>", end="")
-
-
 def main():
-    """
-    Demo function to test the OpenAI-compatible LLM implementation.
-    
-    This function demonstrates:
-    1. Basic chat without tools
-    2. Chat with tool usage (search and code tools)
-    3. Real-time streaming output formatting
-    """
-    from llmflow.tool.dashscope_search_tool import DashscopeSearchTool
-    from llmflow.tool.code_tool import CodeTool
-    from llmflow.enumeration.role import Role
+    from flowllm.utils.common_utils import load_env
 
-    # Load environment variables for API credentials
-    load_dotenv()
+    load_env()
 
-    # Initialize the LLM with a specific model
     model_name = "qwen-max-2025-01-25"
     llm = OpenAICompatibleBaseLLM(model_name=model_name)
-
-    # Set up available tools
-    tools: List[BaseTool] = [DashscopeSearchTool(), CodeTool()]
-
-    # Test 1: Simple greeting without tools
-    print("=== Test 1: Simple Chat ===")
-    llm.stream_print([Message(role=Role.USER, content="hello")], [])
-
-    print("\n" + "=" * 20)
-
-    # Test 2: Complex query that might use tools
-    print("\n=== Test 2: Chat with Tools ===")
-    llm.stream_print([Message(role=Role.USER, content="What's the weather like in Beijing today?")], tools)
-
+    message: Message = llm.chat([Message(role=Role.USER, content="hello")], [],
+                                enable_stream_print=False)
+    print(message)
 
 if __name__ == "__main__":
     main()
-    # Launch with: python -m llmflow.llm.openai_compatible_llm

flowllm/op/__init__.py

@@ -0,0 +1,3 @@
+from flowllm.op.akshare.get_ak_a_code_op import GetAkACodeOp
+from flowllm.op.akshare.get_ak_a_info_op import GetAkAInfoOp, GetAkASpotOp, GetAkAMoneyFlowOp, GetAkAFinancialInfoOp, GetAkANewsOp, MergeAkAInfoOp
+from flowllm.op.mock_op import Mock1Op, Mock2Op, Mock3Op, Mock4Op, Mock5Op, Mock6Op