alayaflow 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

alayaflow/__init__.py

@@ -1,5 +1,7 @@
-"""AlayaFlow - A desktop platform for executing LangGraph workflows with multiple executors."""
+"""AlayaFlow - A workflow engen for management and execution."""
 
+from importlib.metadata import version
+
+__version__ = version("alayaflow")
 
-__version__ = "0.1.3"
 

alayaflow/api/api_singleton.py

@@ -1,4 +1,4 @@
-from typing import Generator, Dict, List, Self, Optional
+from typing import Generator, Dict, List, Self, Optional, AsyncGenerator
 
 from alayaflow.utils.singleton import SingletonMeta
 from alayaflow.workflow import WorkflowManager
@@ -6,6 +6,10 @@ from alayaflow.execution import ExecutorManager, ExecutorType
 from alayaflow.common.config import settings
 from alayaflow.component.model import ModelManager, ModelProfile
 from alayaflow.workflow.runnable import BaseRunnableWorkflow
+from alayaflow.utils.logger import AlayaFlowLogger
+
+
+logger = AlayaFlowLogger()
 
 
 class APISingleton(metaclass=SingletonMeta):
@@ -15,7 +19,7 @@ class APISingleton(metaclass=SingletonMeta):
             workflow_manager=self.workflow_manager
         )
         self.model_manager = ModelManager()
-        self._inited = False                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
+        self._inited = False                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
 
     def is_inited(self) -> bool:
         return self._inited
@@ -34,6 +38,8 @@ class APISingleton(metaclass=SingletonMeta):
         settings.langfuse_public_key = config.get("langfuse_public_key", settings.langfuse_public_key)
         settings.langfuse_secret_key = config.get("langfuse_secret_key", settings.langfuse_secret_key)
         settings.langfuse_url = config.get("langfuse_url", settings.langfuse_url)
+
+        logger.info(f"AlayaFlow is initialized with config: {settings.model_dump()}")
         
         self._inited = True
         return self
@@ -97,3 +103,22 @@ class APISingleton(metaclass=SingletonMeta):
             executor_type=executor_type
         ):
             yield event
+
+    async def exec_workflow_async(
+        self,
+        workflow_id: str,
+        version: str,
+        inputs: dict,
+        context: dict,
+        executor_type: str | ExecutorType = ExecutorType.NAIVE
+    ) -> AsyncGenerator[dict, None]:
+        """异步执行工作流"""
+        self._check_init()
+        async for event in self.executor_manager.exec_workflow_async(
+            workflow_id=workflow_id,
+            version=version,
+            inputs=inputs,
+            context=context,
+            executor_type=executor_type
+        ):
+            yield event

alayaflow/clients/alayamem/base_client.py

@@ -2,18 +2,30 @@ from abc import ABC, abstractmethod
 from typing import Dict, List, Any
 
 class BaseAlayaMemClient(ABC):
+
+
+    @abstractmethod
+    def query_file(self, user_id: str, message: Any, limit: int = 10, use_query_params: bool = False) -> Dict:
+        """ 查询文件内容 - POST 请求 """
+        pass
+
     @abstractmethod
-    def init_session(self, user_id: str, session_id: str) -> Dict:
+    def commit_turn(self, session_id: str, user_text: str, assistant_text: str,
+                    user_id: str = None, window_size: int = 10) -> Dict:
+        """ 提交多轮对话记录 - POST 请求 """
         pass
 
     @abstractmethod
-    def vdb_query(self, messages: List[Any], limit: int) -> Dict:
+    def turns(self, session_id: str, user_id: str = None, limit: int = 10) -> List:
+        """ 查询对话历史记录 - GET 请求 """
         pass
 
     @abstractmethod
-    def add_session_messages(self, user_id: str, session_id: str, messages: List[Any]) -> None:
+    def summary(self, session_id: str, user_id: str = None) -> Dict:
+        """ 查询会话摘要 - GET 请求 """
         pass
 
     @abstractmethod
-    def query(self, user_id: str, session_id: str, message: Any) -> Dict:
+    def profile(self, user_id: str) -> Dict:
+        """ 查询用户画像 - GET 请求 """
         pass

alayaflow/clients/alayamem/http_client.py

@@ -5,60 +5,83 @@ from alayaflow.clients.alayamem.base_client import BaseAlayaMemClient
 
 
 class HttpAlayaMemClient(BaseAlayaMemClient):
+
     def __init__(self, base_url: str):
-        self.base_url = base_url.rstrip("/")
+        """Initialize the HTTP client with base URL"""
+        self.base_url = base_url.rstrip('/')
 
-    def init_session(self, user_id, user_name, agent_name):
-        return self._post("/init", {
-            "user_id": user_id,
-            "user_name": "unknown",
-            "agent_name": "unknown",
-        })
+    def query_file(self, user_id, message, limit=10, use_query_params=False):
+        """ 查询文件内容 - POST 请求 """
+        query_content = self._msg_content(message)
+        params = {
+                "query": query_content,
+                "user_id": user_id,
+                "limit": limit
+            }   
+        return self._post_with_params("/memory/query_file", params)
+   
 
-    def vdb_query(self, messages: List[Any], limit: int,  collection_name: str):
-        query_text = self._extract_query(messages)
-        return self._post("/vdb/query", {
-            "collection_name": collection_name,
-            "query_text": query_text,
-            "limit": limit,
-        })
+    def commit_turn(self, session_id, user_text, assistant_text, user_id=None, window_size=10):
+        """ 提交多轮对话记录 - POST 请求 """
+        payload = {
+            "session_id": session_id,
+            "user_text": user_text,
+            "assistant_text": assistant_text,
+            "window_size": window_size
+        }
+        if user_id:
+            payload["user_id"] = user_id
+        return self._post("/memory/commit_turn", payload)
 
-    def query(self, user_id, message):
-        return self._post("/query", {
+    def turns(self, session_id, user_id=None, limit=10):
+        """ 查询对话历史记录 - GET 请求 """
+        params = {
+            "session_id": session_id,
+            "limit": limit
+        }
+        if user_id:
+            params["user_id"] = user_id
+        return self._get("/memory/turns", params)
+
+    def summary(self, session_id, user_id=None):
+        """ 查询会话摘要 - GET 请求 """
+        params = {
+            "session_id": session_id,
+        }
+        if user_id:
+            params["user_id"] = user_id
+        return self._get("/memory/summary", params)
+
+    def profile(self, user_id):
+        """ 查询用户画像 - GET 请求 """
+        return self._get("/memory/profile", {
             "user_id": user_id,
-            "question": self._msg_content(message),
         })
 
-    def add_session_messages(self, user_id, messages):
-        for msg in messages:
-            return self._post("/add_message", {
-                                "user_id": user_id,
-                                "message": self._msg_content(msg),
-                                "is_user": self._is_user(msg),
-                                "speaker_name": "unknown",
-                            })
 
-    # ---------- private helpers ----------
+
+    # ---------- 私有辅助方法 ----------
+    def _get(self, path: str, params: dict):
+        """发送 GET 请求，参数作为 query string"""
+        resp = requests.get(f"{self.base_url}{path}", params=params)
+        resp.raise_for_status()
+        return resp.json()
 
     def _post(self, path: str, payload: dict):
+        """发送 POST 请求，参数作为 JSON Body"""
         resp = requests.post(f"{self.base_url}{path}", json=payload)
         resp.raise_for_status()
         return resp.json()
 
+    def _post_with_params(self, path: str, params: dict):
+        """发送 POST 请求，参数作为 Query Parameters"""
+        resp = requests.post(f"{self.base_url}{path}", params=params)
+        resp.raise_for_status()
+        return resp.json()
+
     def _msg_content(self, msg):
         # 支持字典格式
         if isinstance(msg, dict):
             return msg.get("content", str(msg))
         # 支持对象格式
         return msg.content if hasattr(msg, "content") else str(msg)
-
-    def _extract_query(self, messages):
-        if not messages:
-            return ""
-        last_msg = messages[-1]
-        return self._msg_content(last_msg)
-
-    def _is_user(self, msg):
-        if isinstance(msg, dict):
-            return msg.get("role", "").lower() == "user"
-        return "Human" in msg.__class__.__name__ or "User" in msg.__class__.__name__

alayaflow/common/config.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 from typing import Literal, Optional
-from pydantic import model_validator
+
+from pydantic import model_validator, Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 class Settings(BaseSettings):
@@ -24,8 +25,9 @@ class Settings(BaseSettings):
     workspace_root: Optional[Path] = None
     resources_root: Optional[Path] = None
     workflow_storage_path: Optional[Path] = None
-    agent_storage_path: Optional[Path] = None
-    app_storage_path: Optional[Path] = None
+
+    log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO"
+    log_dir: Optional[Path] = None
     
     alayahub_url: str = "http://localhost:8000"
 
@@ -84,6 +86,11 @@ class Settings(BaseSettings):
         else:
             self.workflow_storage_path = Path(self.workflow_storage_path)
 
+        if self.log_dir is None:
+            self.log_dir = self.workspace_root / "logs"
+        else:
+            self.log_dir = Path(self.log_dir)
+
         return self
 
     @model_validator(mode='after')
@@ -98,9 +105,4 @@ class Settings(BaseSettings):
         
         return self
 
-    @model_validator(mode='after')
-    def print_config(self):
-        print(self.model_dump())
-        return self
-
 settings = Settings()

alayaflow/component/memory.py

@@ -1,50 +1,52 @@
 from alayaflow.clients.alayamem.http_client import HttpAlayaMemClient
 
 
-def query_vdb_message(alayamem_url: str, messages, limit, collection_name = "file_watcher_collection"):
+def query_file(alayamem_url: str, user_id: str, message):
     mem_client = HttpAlayaMemClient(alayamem_url)
     try:
-        result = mem_client.vdb_query(messages, limit, collection_name)
-        return {"vdb_results": result.get("results", []), "vdb_response": result}
+        return mem_client.query_file(user_id, message)
     except Exception as e:
-        return {"vdb_results": [], "error": str(e)}
+        print(f"[Query File] Error: {e}")
+        return {"error": str(e)}
 
 
-def init_memory(alayamem_url: str, user_id, user_name="unknown", agent_name="unknown"):
+def commit_turn(alayamem_url: str, session_id: str, user_text: str,
+                assistant_text: str, user_id: str = None, window_size: int = 3):
+    """ 提交多轮对话记录 """
     mem_client = HttpAlayaMemClient(alayamem_url)
     try:
-        return mem_client.init_session(user_id, user_name, agent_name)
+        return mem_client.commit_turn(session_id, user_text, assistant_text,
+                                     user_id, window_size)
     except Exception as e:
-        return {"memory_initialized": False}
+        print(f"[Commit Turn] Error: {e}")
+        return {"error": str(e)}
 
 
-def query_message(alayamem_url: str, user_id, messages):
+def turns(alayamem_url: str, session_id: str, user_id: str = None, limit: int = 10):
+    """ 查询对话历史记录 """
     mem_client = HttpAlayaMemClient(alayamem_url)
+    try:
+        return mem_client.turns(session_id, user_id, limit)
+    except Exception as e:
+        print(f"[Turns] Error: {e}")
+        return {"error": str(e)}
 
-    if not messages:
-        return
 
-    last_message = messages[-1]
-    
+def summary(alayamem_url: str, session_id: str, user_id: str = None):
+    """ 查询会话摘要 """
+    mem_client = HttpAlayaMemClient(alayamem_url)
     try:
-        resp = mem_client.query(user_id, last_message)
+        return mem_client.summary(session_id, user_id)
     except Exception as e:
-        print(f"[Query User Message] Error: {e}")
-        return []
+        print(f"[Summary] Error: {e}")
+        return {"error": str(e)}
 
-    return resp
 
 
-def add_message(alayamem_url: str, user_id, session_id, messages):
+def profile(alayamem_url: str, user_id: str):
     mem_client = HttpAlayaMemClient(alayamem_url)
-
-    if not messages:
-        return
-
     try:
-        return mem_client.add_session_messages(user_id, messages)
+        return mem_client.profile(user_id)
     except Exception as e:
-        print(f"[Add Messages] Error: {e}")
-        pass
-
-    return
+        print(f"[Profile] Error: {e}")
+        return {"error": str(e)}

alayaflow/execution/executor_manager.py

@@ -1,4 +1,4 @@
-from typing import Dict, Generator, Any
+from typing import Dict, Generator, Any, AsyncGenerator
 from enum import Enum
 
 from alayaflow.execution.executors.base_executor import BaseExecutor
@@ -57,3 +57,21 @@ class ExecutorManager:
         executor = self._executor_map[executor_type]
         yield from executor.execute_stream(workflow_id, version, inputs, context)
 
+    async def exec_workflow_async(
+            self, 
+            workflow_id: str,
+            version: str, 
+            inputs: dict,
+            context: dict, 
+            executor_type: ExecutorType | str = ExecutorType.NAIVE
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        if isinstance(executor_type, str):
+            executor_type = ExecutorType(executor_type)
+        if executor_type not in self._executor_map:
+            raise ValueError(
+                f"Unsupported executor kind: {executor_type}. "
+                f"Supported kinds: {list(self._executor_map.keys())}"
+            )
+        executor = self._executor_map[executor_type]
+        async for event in executor.execute_stream_async(workflow_id, version, inputs, context):
+            yield event

alayaflow/execution/executors/base_executor.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Generator, Dict
+from typing import Generator, Dict, AsyncGenerator
 
 
 class BaseExecutor(ABC):
@@ -7,3 +7,7 @@ class BaseExecutor(ABC):
     def execute_stream(self, workflow_id: str, version: str, inputs: dict, context: dict) -> Generator[Dict, None, None]:
         pass
 
+    @abstractmethod
+    async def execute_stream_async(self, workflow_id: str, version: str, inputs: dict, context: dict) -> AsyncGenerator[Dict, None]:
+        pass
+

alayaflow/execution/executors/naive_executor.py

@@ -2,15 +2,18 @@ import asyncio
 import traceback
 import queue
 import threading
-from typing import Generator, Dict, Optional, Any
+from typing import Generator, Dict, Any, AsyncGenerator
 
 from alayaflow.execution.executors.base_executor import BaseExecutor
+from alayaflow.utils.coroutine import iter_sync
 from alayaflow.workflow.workflow_manager import WorkflowManager
 from alayaflow.workflow.runnable import BaseRunnableWorkflow, StateGraphRunnableWorkflow
 from alayaflow.common.config import settings
 from alayaflow.execution.langfuse_tracing import get_tracing
+from alayaflow.utils.logger import AlayaFlowLogger
+
+logger = AlayaFlowLogger()
 
-_SENTINEL = object()
 
 class NaiveExecutor(BaseExecutor):
     def __init__(self, workflow_manager: WorkflowManager):
@@ -39,65 +42,30 @@ class NaiveExecutor(BaseExecutor):
             inputs: dict, 
             context: dict
     ) -> Generator[Dict, None, None]:
+        return iter_sync(self.execute_stream_async(workflow_id, version, inputs, context))
 
-        # 1) resolve workflow
+    async def execute_stream_async(
+            self, 
+            workflow_id: str, 
+            version: str, 
+            inputs: dict, 
+            context: dict
+    ) -> AsyncGenerator[Dict, None]:
         try:
             runnable = self.workflow_manager.get_workflow_runnable(workflow_id, version)
         except ValueError as e:
             yield {"error": str(e), "workflow_id": workflow_id, "version": version}
             return
 
-        print(f"NaiveExecutor execute_stream: {workflow_id} {version} {inputs} {context}")
+        logger.info(f"Execute workflow.\n{workflow_id=} {version=}\n{inputs=}\n{context=}")
 
         # TODO: Support langflow workflow
-        # Only support StateGraphRunnableWorkflow now. 
-        # As in _produce_events_to_queue, we relay on the "configurable" (StateGraph only) to use langfuse tracing.
+        # Only support StateGraphRunnableWorkflow for now
+        # check it as we pass a langgraph specific config here
         if not isinstance(runnable, StateGraphRunnableWorkflow):
             raise ValueError(f"NaiveExecutor only supports StateGraphRunnableWorkflow, but got {type(runnable)}")
 
-        # 3) async -> sync bridge
-        event_queue = queue.Queue(maxsize=1000)
-
-        def run_async_producer():
-            try:
-                asyncio.run(self._produce_events_to_queue(runnable, inputs, context, event_queue))
-            except Exception as e:
-                event_queue.put({"error": str(e), "traceback": traceback.format_exc(), "workflow_id": workflow_id, "version": version})
-            finally:
-                event_queue.put(_SENTINEL)
-
-        producer_thread = threading.Thread(target=run_async_producer, daemon=True)
-        producer_thread.start()
-
-        # 4) stream
-        while True:
-            try:
-                item = event_queue.get(timeout=1.0)
-            except queue.Empty:
-                if not producer_thread.is_alive():
-                    saw_sentinel = False
-                    while True:
-                        try:
-                            item = event_queue.get_nowait()
-                            if item is _SENTINEL:
-                                saw_sentinel = True
-                                break
-                            yield self._serialize_event(item)
-                        except queue.Empty:
-                            break
-                    if saw_sentinel:
-                        break
-                    yield {"error": "producer thread exited unexpectedly", "workflow_id": workflow_id, "version": version}
-                    break
-                continue
-            if item is _SENTINEL:
-                break
-            yield self._serialize_event(item)
-
-    
-    async def _produce_events_to_queue(self, runnable: BaseRunnableWorkflow, inputs: dict, context: dict, event_queue: queue.Queue):
         try:
-            # Setup tracing
             tracing = get_tracing(settings)
             langfuse_cb = tracing.build_callback()
         
@@ -107,13 +75,7 @@ class NaiveExecutor(BaseExecutor):
                 config = {}
             
             async for chunk in runnable.stream_events_async(inputs, context, config):
-                event_queue.put(chunk)  # Put each event immediately (real-time)
+                yield self._serialize_event(chunk)
         except Exception as e:
-            # If execution fails, put error event in queue
-            event_queue.put({
-                "error": str(e),
-                "traceback": traceback.format_exc(),
-                "workflow_id": runnable.info.id,
-                "version": runnable.info.version
-            })
+            yield {"error": str(e), "traceback": traceback.format_exc(), "workflow_id": workflow_id, "version": version}
 

alayaflow/execution/executors/uv_executor.py

@@ -1,7 +1,7 @@
 import socket
 import os
 import struct
-from typing import Generator, Dict, Optional
+from typing import Generator, Dict, Optional, AsyncGenerator
 from pathlib import Path
 
 from alayaflow.execution.executors.base_executor import BaseExecutor
@@ -123,3 +123,12 @@ class UvExecutor(BaseExecutor):
         #     if stderr:
         #         print(f"[Stderr] {stderr}")
 
+
+    def execute_stream_async(
+        self,
+        workflow_id: str,
+        version: str,
+        inputs: dict,
+        context: dict,
+    ) -> AsyncGenerator[Dict, None]:
+        raise NotImplementedError("uv executor not supported yet")

alayaflow/execution/executors/worker_executor.py

@@ -1,4 +1,4 @@
-from typing import Generator, Dict
+from typing import Generator, Dict, AsyncGenerator
 
 from alayaflow.execution.executors.base_executor import BaseExecutor
 from alayaflow.workflow.workflow_manager import WorkflowManager
@@ -10,3 +10,5 @@ class WorkerExecutor(BaseExecutor):
     def execute_stream(self, workflow_id: str, version: str, inputs: dict, context: dict) -> Generator[Dict, None, None]:
         raise NotImplementedError("worker executor not supported yet")
 
+    def execute_stream_async(self, workflow_id: str, version: str, inputs: dict, context: dict) -> AsyncGenerator[Dict, None]:
+        raise NotImplementedError("worker executor not supported yet")

alayaflow/utils/coroutine.py

@@ -0,0 +1,20 @@
+import queue, threading, asyncio
+
+def iter_sync(async_gen):
+    """将 AsyncGenerator 转为 Sync Generator"""
+    q = queue.Queue(maxsize=1)
+    SENTINEL = object()
+
+    def _run():
+        try:
+            async def _drive():
+                async for item in async_gen: q.put(item)
+            asyncio.run(_drive())
+        except Exception as e: q.put(e)
+        finally: q.put(SENTINEL)
+
+    threading.Thread(target=_run, daemon=True).start()
+
+    for item in iter(q.get, SENTINEL):
+        if isinstance(item, Exception): raise item
+        yield item

alayaflow/utils/logger.py

@@ -0,0 +1,79 @@
+import logging
+import sys
+import threading
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+from typing import Optional
+
+from alayaflow.common.config import settings
+
+
+FILE_ONLY_KEY = "_file_only"
+
+class AlayaFlowLogger:
+    _instance: Optional[logging.Logger] = None
+    _lock: threading.Lock = threading.Lock()
+
+    def __new__(cls) -> logging.Logger:
+        if cls._instance is None:
+            with cls._lock:
+                # Double-check locking
+                if cls._instance is None:
+                    cls._instance = logging.getLogger("alayaflow")
+                    cls._initialize_logger(cls._instance)
+        return cls._instance
+
+    @classmethod
+    def _initialize_logger(cls, logger: logging.Logger):
+        if logger.hasHandlers():
+            logger.handlers.clear()
+        
+        logger.setLevel(settings.log_level)
+        logger.propagate = False
+
+        formatter = logging.Formatter(
+            "[%(asctime)s][%(levelname)s][%(filename)s:%(lineno)d][pid:%(process)d] - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+
+        cls._add_console_handler(logger, formatter)
+        cls._add_safe_file_handler(logger, formatter)
+
+    @staticmethod
+    def _add_console_handler(logger: logging.Logger, formatter: logging.Formatter):
+        console = logging.StreamHandler(stream=sys.stderr)
+        console.setFormatter(formatter)
+
+        console.addFilter(lambda r: not getattr(r, FILE_ONLY_KEY, False))
+        
+        if not settings.is_dev():
+            console.setLevel(logging.ERROR)
+
+        logger.addHandler(console)
+
+    @staticmethod
+    def _add_safe_file_handler(logger: logging.Logger, formatter: logging.Formatter):
+        """尝试添加文件 Handler，如果失败（如权限问题）则仅记录一次警告"""
+        log_dir = Path(settings.log_dir)
+        log_path = log_dir / "alayaflow.log"
+
+        try:
+            log_dir.mkdir(parents=True, exist_ok=True)
+            
+            file_handler = RotatingFileHandler(
+                log_path, 
+                maxBytes=10 * 1024 * 1024, # 10MB
+                backupCount=5,
+                encoding='utf-8'
+            )
+            file_handler.setFormatter(formatter)
+            file_handler.setLevel(logging.DEBUG if settings.is_dev() else logging.INFO)
+            logger.addHandler(file_handler)
+            
+        except (PermissionError, OSError) as e:
+            logger.warning(
+                "[AlayaFlowLogger] Cannot open log file under %s (%s); "
+                "logging will rely on console output.",
+                log_dir,
+                e,
+            )

{alayaflow-0.1.3.dist-info → alayaflow-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alayaflow
-Version: 0.1.3
+Version: 0.1.4
 Summary: A desktop platform for executing LangGraph workflows with uv-managed sandboxes.
 Author-email: alayaflow group <dev@example.com>
 License: MIT

{alayaflow-0.1.3.dist-info → alayaflow-0.1.4.dist-info}/RECORD

@@ -1,14 +1,14 @@
-alayaflow/__init__.py,sha256=ZQGg3KVDYQcq_LK1TLcFuRtc1KFKYva_AoumPeVlOMM,121
+alayaflow/__init__.py,sha256=UbyJ0npjvUjHLpleqyLFoZxq8iy0qjgA8LwFKebXgeI,143
 alayaflow/api/__init__.py,sha256=y6nWgqC3jhOffTqixKlv3OU_NEAFxbzHSvwJrE5bHNs,187
-alayaflow/api/api_singleton.py,sha256=SvWeLHPYHT1ABACwmoNj2dWrFjpqLCpSMz1-KW3hsZQ,11640
-alayaflow/clients/alayamem/base_client.py,sha256=pyU2WF2jqNEgBEe8JOZSg13gHQ2pJcBgJ_6YP-5mWkw,540
-alayaflow/clients/alayamem/http_client.py,sha256=n0hAh_ddzEwFfNMsdw5s2dqvuMsyZNGOT-RcHsIXuEw,2171
-alayaflow/common/config.py,sha256=pi4zH_Pi0u6Fb8ZIs4u3qFOUOUeqxxUqqksoUp-hynM,3806
+alayaflow/api/api_singleton.py,sha256=7gSytjx80q3Cs6Edfu4t5D3XyArrPTDerCaYjZ8EymA,12362
+alayaflow/clients/alayamem/base_client.py,sha256=KYBHqnU2lfouQuLTSlNfIn8CyCk-IR9mRW_GzVqpxaI,989
+alayaflow/clients/alayamem/http_client.py,sha256=oJHLYemhPa5KRwZAY-g9uzMM8haFLnTUBWkgX-G29Ks,2933
+alayaflow/common/config.py,sha256=olyjg-csRt4dHwwHQ8Duh7qvAQXrkSBiBQ2OAoo6HuA,3874
 alayaflow/component/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alayaflow/component/chat_model.py,sha256=GH2xcOhtvh3YqN2LMITmu1j-0_-t9d4hiMuRFctF2og,402
 alayaflow/component/intent_classifier.py,sha256=5KH52LIqIDpw2hlX4gi3Ff7SFVhenCFdFV-fXag0sDM,3765
 alayaflow/component/llm_node.py,sha256=2QfiWew99EVQ05UpA7IkepefpOFHqb4Wxo_tYOipekc,3496
-alayaflow/component/memory.py,sha256=Xl5ABW89dswC9oMwkeS6NFAZniKFw8BuGuLAAHddRRA,1448
+alayaflow/component/memory.py,sha256=ZWmpyJriSwNBP4nhQpq4q7bCnnLc6W_oVEJMSKegdLI,1738
 alayaflow/component/retrieve_node.py,sha256=FlKyGH767ZbS4ss5SGcprp-sRsY4jA0YdlNP4OFzgQU,2842
 alayaflow/component/search_node.py,sha256=JNFD6qXDd2_NPpXQf7z8xklJFZs7UrFhWet43nrs25Y,4950
 alayaflow/component/web_search.py,sha256=HZp9j0X0YMBC_mhGqzi0g0pbvmlWiLiNdRxzbEFzl6s,3403
@@ -19,14 +19,16 @@ alayaflow/component/model/model_manager.py,sha256=VTqkCLXxhGqSXi7GcBxaRHw3wTTfEk
 alayaflow/component/model/schemas.py,sha256=YADx6OGltGMzpUSNEYcUbGOrrJvtV6dFdAub3FfAw9w,1404
 alayaflow/execution/__init__.py,sha256=9gj_xgIJxlq3EuwsDMb5X05yP70HoD0_T25Khd495Xc,117
 alayaflow/execution/env_manager.py,sha256=-7npm1f-FNhHyOt8NZGbGA3i7JMHqQXoWV1uAe1bpyE,16744
-alayaflow/execution/executor_manager.py,sha256=_t_tr58yUsMbIW_xfevUXv8ba-7lGbBJFhjPsQ-ricM,2147
+alayaflow/execution/executor_manager.py,sha256=CQ-G7ROEge42-rJUXaRP_c_Us23-8epv2euKl_FbtpE,2944
 alayaflow/execution/langfuse_tracing.py,sha256=BuRMHDH7Gub7CMkJM5ECLzs4vjy3VqAgzh2INE9zbOI,3882
 alayaflow/execution/workflow_runner.py,sha256=XEX4Em0Hv1sI8Im0lREjXq3fN1jYVwFnMMW3pphIAZk,3243
 alayaflow/execution/executors/__init__.py,sha256=RYwYg880smrZ8EX5iwVsJe0Rtgo8-tF82pY5jA3926g,412
-alayaflow/execution/executors/base_executor.py,sha256=mtBJM9bo_VLWAG9nnuq9xCjlD83bsvk1NPY5-aeD8TQ,254
-alayaflow/execution/executors/naive_executor.py,sha256=ICXslitv-9ONvJ3kLC-3-vTTBg1dWQlp0evCtxMO_MI,4749
-alayaflow/execution/executors/uv_executor.py,sha256=IIwP4j-BuDmfNoizuLsHcW0hRmzsLArWRVtVToX3_dM,4622
-alayaflow/execution/executors/worker_executor.py,sha256=niyTqsxB1iHvkuYb3xd35UwnsQllKul-Z6ikenJZ9Hk,513
+alayaflow/execution/executors/base_executor.py,sha256=bRgPlT5Z7Fwu1aje0Vvk5OdxBkLSmBw7cIEf2aVNP5Y,437
+alayaflow/execution/executors/naive_executor.py,sha256=Jf2unKrOuon9R-4bQP5_n3GkjXwFPBBSZXBH7E2puBg,3149
+alayaflow/execution/executors/uv_executor.py,sha256=VttozDIPPvoE2empkTs_qt9Spep5ZsC4bX84rUmokEs,4879
+alayaflow/execution/executors/worker_executor.py,sha256=NN9PKTGZjxLBdLVcj-EFX9Mz46VPAA2VjCo1ole7wzU,726
+alayaflow/utils/coroutine.py,sha256=709UGiY9dY-292YIVzTyqojg9HGigovfWK7R4-sPiyk,557
+alayaflow/utils/logger.py,sha256=CIz8m14gQa3hgT7K4XbmNpplZPiEowS2MCbo19OLuMQ,2638
 alayaflow/utils/singleton.py,sha256=5crFVfOkr9pU_j83ywqAMaL07BvVN5Ke_VGjT9qyUN0,432
 alayaflow/workflow/__init__.py,sha256=mzqmL4P7q7ixTp2b0rZE-5iEBh7vv4YaTyvqnQZKmos,267
 alayaflow/workflow/workflow_info.py,sha256=rnpAwYE4trhiv7o8LPmQpyQ3CDFfNN2yk1CLKRnWz0w,1259
@@ -35,7 +37,7 @@ alayaflow/workflow/workflow_manager.py,sha256=dUFS6B5V64mdsopxrM6f3LvJn497eTBqMJ
 alayaflow/workflow/runnable/__init__.py,sha256=sNybFeRxLwbDLHiZxlVFXsn3w2n1Jn0Mtun2W6fvjFU,257
 alayaflow/workflow/runnable/base_runnable_workflow.py,sha256=ap53fOeC5iUh2zm45LpEDjLJ4uqfO2C6FCN6WGm13kw,776
 alayaflow/workflow/runnable/state_graph_runnable_workflow.py,sha256=PMSHks46kmNM2uDVmf5TNcLW7AR6dgfJFohxs8Dcfm4,972
-alayaflow-0.1.3.dist-info/METADATA,sha256=aMfRyIwPukXW80Am5h8ApPNiBbL4mRZcfaOtMQflVL4,1925
-alayaflow-0.1.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-alayaflow-0.1.3.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-alayaflow-0.1.3.dist-info/RECORD,,
+alayaflow-0.1.4.dist-info/METADATA,sha256=bpHrxG1f9BLNqnUDYV7i1HULypER6DNFT57gPhHe1CM,1925
+alayaflow-0.1.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+alayaflow-0.1.4.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+alayaflow-0.1.4.dist-info/RECORD,,