yak-browser-use 0.5.3.post4.dev0__tar.gz → 0.5.5.dev0__tar.gz

{yak_browser_use-0.5.3.post4.dev0/src/yak_browser_use.egg-info → yak_browser_use-0.5.5.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yak-browser-use
-Version: 0.5.3.post4.dev0
+Version: 0.5.5.dev0
 Summary: A clean, learnable browser automation framework — Chat mode + Preset replay via Playwright CDP
 Author-email: SlimeSB <x56277534@gmail.com>
 License-Expression: MIT
@@ -26,10 +26,7 @@ Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: fastapi>=0.115.0
 Requires-Dist: uvicorn[standard]>=0.30.0
-Requires-Dist: websockets==15.0.1
-Provides-Extra: dev
-Requires-Dist: pytest>=8.0.0; extra == "dev"
-Requires-Dist: pytest-asyncio>=0.25.0; extra == "dev"
+Requires-Dist: websockets>=15.0
 
 <p align="center">
   <picture>

{yak_browser_use-0.5.3.post4.dev0 → yak_browser_use-0.5.5.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [build-system]
 requires = ["setuptools>=64", "setuptools-scm>=8"]
-build-backend = "setuptools.build_meta:__legacy__"
+build-backend = "setuptools.build_meta"
 
 [project]
 name = "yak-browser-use"
@@ -32,7 +32,7 @@ dependencies = [
     "pyyaml>=6.0",
     "fastapi>=0.115.0",
     "uvicorn[standard]>=0.30.0",
-    "websockets==15.0.1",
+    "websockets>=15.0",
 ]
 
 [project.urls]
@@ -40,19 +40,13 @@ Homepage = "https://github.com/SlimeSB/yak-browser-use"
 Source = "https://github.com/SlimeSB/yak-browser-use"
 BugTracker = "https://github.com/SlimeSB/yak-browser-use/issues"
 
-[project.optional-dependencies]
-dev = [
-    "pytest>=8.0.0",
-    "pytest-asyncio>=0.25.0",
-]
-
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 
 [dependency-groups]
 dev = [
-    "pytest>=9.0.3",
-    "pytest-asyncio>=1.4.0",
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.25.0",
 ]
 
 [tool.setuptools.packages.find]

yak_browser_use-0.5.5.dev0/src/yak_browser_use/api/event_bus.py

@@ -0,0 +1,55 @@
+"""EventBus — centralized event dispatch for chat and pipeline events.
+
+Routes events to:
+- Registered callbacks (e.g. WebSocket manager)
+- Engine state WS client queues
+- (Pipeline events also go through EventSink, which is separate)
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Callable
+
+from yak_browser_use.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class EventBus:
+    """Pushes structured events to callbacks and engine-state WS clients.
+
+    Tracks a ``chat_streaming`` flag so ``chat.message`` events can be
+    suppressed during streaming (the delta chunks are sent via individual
+    streaming callbacks, so the full message event is redundant).
+    """
+
+    def __init__(self, engine_state: Any | None = None):
+        self._engine_state = engine_state
+        self._event_callbacks: list[Callable[[dict], None]] = []
+        self.chat_streaming: bool = False
+
+    def on_event(self, callback: Callable[[dict], None]) -> None:
+        """Register a callback for event streaming."""
+        self._event_callbacks.append(callback)
+
+    def push(self, event: dict) -> None:
+        """Push an event to all registered callbacks AND engine-state WS clients.
+
+        ``chat.message`` events are silently dropped while
+        ``chat_streaming`` is active to avoid duplicating the delta stream.
+        """
+        if event.get("type") == "chat.message" and self.chat_streaming:
+            return
+        event["_ts"] = time.time()
+        for cb in self._event_callbacks:
+            try:
+                cb(event)
+            except Exception:
+                logger.warning("Event callback failed for type=%s", event.get("type"), exc_info=True)
+        if self._engine_state and hasattr(self._engine_state, "ws_clients"):
+            for q in self._engine_state.ws_clients:
+                try:
+                    q.put_nowait(event)
+                except Exception:
+                    pass

{yak_browser_use-0.5.3.post4.dev0 → yak_browser_use-0.5.5.dev0}/src/yak_browser_use/api/routes.py

@@ -186,13 +186,11 @@ def register_all_routes(app: FastAPI) -> None:
             from yak_browser_use.cdp.helpers import CDPHelpers
             browser = CDPHelpers(engine_state.bridge)
 
-            # Import run_pipeline with fallback (being written simultaneously)
             try:
-                from yak_browser_use.engine.runner import run_pipeline
+                from yak_browser_use.engine.runner_preset import run_pipeline
             except ImportError:
                 raise ServerError(
-                    "engine.runner is not yet available — pipeline execution cannot start. "
-                    "Ensure engine/runner.py is implemented."
+                    "engine.runner_preset is not yet available — pipeline execution cannot start."
                 )
 
             ctx = await run_pipeline(
@@ -205,12 +203,14 @@ def register_all_routes(app: FastAPI) -> None:
             )
 
             status = "completed" if not ctx.errors else "failed"
+            first_error = ctx.errors[0].get("message", str(ctx.errors[0])) if ctx.errors else None
             return JSONResponse({
                 "run_id": ctx.run_id,
                 "pipeline": ctx.pipeline_name,
                 "status": status,
                 "step_count": len(steps),
                 "errors": ctx.errors,
+                "error": first_error,
             })
         except APIError:
             raise
@@ -670,9 +670,9 @@ def register_all_routes(app: FastAPI) -> None:
             snapshot_path.write_text(pipeline_text, encoding="utf-8")
 
             try:
-                from yak_browser_use.engine.runner import run_pipeline
+                from yak_browser_use.engine.runner_preset import run_pipeline
             except ImportError:
-                raise ServerError("engine.runner is not yet available")
+                raise ServerError("engine.runner_preset is not yet available")
 
             from yak_browser_use.cdp.helpers import CDPHelpers
             browser = CDPHelpers(engine_state.bridge)
@@ -813,7 +813,7 @@ def register_all_routes(app: FastAPI) -> None:
         turn_index = (len(session.messages) if session else 0) + 1
 
         def _push(event: dict) -> None:
-            service._push_event(event)
+            service.events.push(event)
 
         def _on_stream_start() -> None:
             _push({"type": "chat.stream_start", "turn_index": turn_index})
@@ -1073,8 +1073,31 @@ def register_all_routes(app: FastAPI) -> None:
             for d in sorted(workspaces_dir.iterdir()):
                 if not d.is_dir() or d.name.startswith("."):
                     continue
-                if (d / "pipeline.yaml").exists():
-                    pipelines.append({"name": d.name, "title": d.name})
+                pipe_file = d / "pipeline.yaml"
+                if pipe_file.exists():
+                    name = d.name
+                    description = ""
+                    stages: list[str] = []
+                    step_count = 0
+                    try:
+                        import yaml
+                        raw = yaml.safe_load(pipe_file.read_text(encoding="utf-8"))
+                        if isinstance(raw, dict):
+                            name = raw.get("name", name)
+                            description = raw.get("description", "")
+                            steps_raw = raw.get("steps", [])
+                            if isinstance(steps_raw, list):
+                                stages = [s.get("name", f"step_{i}") for i, s in enumerate(steps_raw)]
+                                step_count = len(steps_raw)
+                    except Exception:
+                        pass
+                    pipelines.append({
+                        "name": name,
+                        "title": name,
+                        "description": description,
+                        "stages": stages,
+                        "step_count": step_count,
+                    })
         return JSONResponse({"pipelines": pipelines})
 
     @app.get("/api/pipelines/{name}")
@@ -1086,7 +1109,21 @@ def register_all_routes(app: FastAPI) -> None:
         if not pipe_path.exists():
             raise APIError("pipeline not found", status_code=404)
         content = pipe_path.read_text(encoding="utf-8")
-        return JSONResponse({"name": name, "content": content})
+        meta: dict = {"name": name, "title": name, "description": "", "stages": [], "step_count": 0}
+        try:
+            import yaml
+            raw = yaml.safe_load(content)
+            if isinstance(raw, dict):
+                meta["name"] = raw.get("name", name)
+                meta["title"] = meta["name"]
+                meta["description"] = raw.get("description", "")
+                steps_raw = raw.get("steps", [])
+                if isinstance(steps_raw, list):
+                    meta["stages"] = [s.get("name", f"step_{i}") for i, s in enumerate(steps_raw)]
+                    meta["step_count"] = len(steps_raw)
+        except Exception:
+            pass
+        return JSONResponse({"name": name, "content": content, "meta": meta})
 
     @app.delete("/api/pipelines/{name}")
     async def api_delete_pipeline(name: str) -> JSONResponse:
@@ -1111,7 +1148,7 @@ def register_all_routes(app: FastAPI) -> None:
         Each connected client receives event dicts as JSON text messages.
         """
         await websocket.accept()
-        q: asyncio.Queue = asyncio.Queue()
+        q: asyncio.Queue = asyncio.Queue(maxsize=256)
         engine_state.ws_clients.append(q)
         logger.debug("WebSocket client connected (%d total)", len(engine_state.ws_clients))
 

{yak_browser_use-0.5.3.post4.dev0 → yak_browser_use-0.5.5.dev0}/src/yak_browser_use/api/server.py

@@ -23,6 +23,9 @@ async def lifespan(app: FastAPI):
     from yak_browser_use.api.state import engine_state
 
     await engine_state.cleanup()
+    from yak_browser_use.cdp.discover import cleanup as cleanup_discover
+
+    await cleanup_discover()
     logger.info("Yak Browser-Use API stopped")
 
 
@@ -44,7 +47,6 @@ def create_app() -> FastAPI:
     app.add_middleware(
         CORSMiddleware,
         allow_origins=["*"],
-        allow_credentials=True,
         allow_methods=["*"],
         allow_headers=["*"],
     )

yak_browser_use-0.5.5.dev0/src/yak_browser_use/api/service.py

@@ -0,0 +1,245 @@
+"""API service layer — session/chat/pipeline business logic.
+
+Bridges the API routes to the engine: session management,
+chat message processing, pipeline compilation, and event pushing.
+
+Delegates to :class:`SessionManager` and :class:`EventBus` for the
+respective sub-domains; Service itself handles chat orchestration
+and pipeline utilities.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Callable
+
+from yak_browser_use.utils.logging import get_logger
+
+from yak_browser_use.api.errors import APIError
+from yak_browser_use.api.event_bus import EventBus
+from yak_browser_use.api.session_manager import SessionManager, SessionState, _DEFAULT_PIPELINE
+from yak_browser_use.workspace.manager import WORKSPACES_ROOT
+from yak_browser_use.tools.todo_store import current_store
+
+logger = get_logger(__name__)
+
+_WORKSPACES_DIR = WORKSPACES_ROOT
+
+
+def _build_pipeline_context(pipeline_name: str) -> str | None:
+    """Build a markdown snippet describing the currently selected pipeline."""
+    import yaml
+
+    pipe_path = _WORKSPACES_DIR / pipeline_name / "pipeline.yaml"
+    if not pipe_path.exists():
+        logger.info("Pipeline %s not found for context injection", pipeline_name)
+        return None
+
+    try:
+        content = pipe_path.read_text(encoding="utf-8")
+        data = yaml.safe_load(content)
+        if not isinstance(data, dict):
+            return None
+
+        name = data.get("name", pipeline_name)
+        goal = data.get("goal", data.get("description", ""))
+        steps = data.get("steps", [])
+
+        lines = [f"## 当前选中的 Pipeline: {name}"]
+        if goal:
+            lines.append(f"目标: {goal}")
+        if steps:
+            lines.append("")
+            lines.append("### 步骤列表")
+            for i, step in enumerate(steps):
+                step_name = step.get("name") if isinstance(step, dict) else str(step)
+                lines.append(f"- {step_name or f'step_{i}'}")
+        lines.append("")
+        lines.append("你可以使用 pipeline_* 工具对此 pipeline 进行操作。")
+        return "\n".join(lines)
+    except Exception as exc:
+        logger.warning("Failed to load pipeline %s context: %s", pipeline_name, exc)
+        return None
+
+
+class Service:
+    """Business logic service for the YBU API.
+
+    Composes :class:`SessionManager` and :class:`EventBus` and
+    exposes the combined interface used by the route layer.
+    """
+
+    def __init__(self, engine_state: object | None = None):
+        self.sessions = SessionManager()
+        self.events = EventBus(engine_state)
+        self.sessions.set_event_pusher(self.events.push)
+        self._chat_lock = asyncio.Lock()
+
+    # ── Session management (delegated) ──────────────────────────────
+
+    def create_session(self, pipeline_name: str = "") -> SessionState:
+        return self.sessions.create_session(pipeline_name)
+
+    def get_session(self, pipeline_name: str | None = None) -> SessionState | None:
+        return self.sessions.get_session(pipeline_name)
+
+    def reset_session(self) -> SessionState:
+        return self.sessions.reset_session()
+
+    def cancel_session(self) -> SessionState | None:
+        return self.sessions.cancel_session()
+
+    def switch_session(self, pipeline_name: str) -> list[dict]:
+        return self.sessions.switch_session(pipeline_name)
+
+    def archive_session(self, pipeline_name: str, session_id: str) -> bool:
+        return self.sessions.archive_session(pipeline_name, session_id)
+
+    def new_session(self, pipeline_name: str) -> dict:
+        return self.sessions.new_session(pipeline_name)
+
+    # ── Chat message processing ─────────────────────────────────────
+
+    async def process_chat_message(
+        self,
+        message: str,
+        *,
+        cdp_helpers: object | None = None,
+        tools_dir: Path | None = None,
+        pipeline_name: str = "",
+        llm_call: Callable | None = None,
+    ) -> dict:
+        """Process a chat message through conversation_loop."""
+        async with self._chat_lock:
+            from yak_browser_use.engine._harness.conversation_loop import (
+                run_conversation_loop,
+                ConversationResult,
+            )
+            from yak_browser_use.engine._harness.tools import get_all_tools
+            from yak_browser_use.prompts._loader import build_system_prompt
+
+            session = self.sessions.get_session(pipeline_name)
+            if session is None:
+                session = self.sessions.create_session(pipeline_name)
+
+            logger.info("Chat [%s] user: %s", session.session_id, message[:120])
+
+            session.status = "running"
+            self.events.push({
+                "type": "session.state",
+                "status": "running",
+                "session_id": session.session_id,
+            })
+
+            session.messages.append({"role": "user", "content": message})
+
+            system_prompt = build_system_prompt()
+
+            normalized = self.sessions.normalize_pipeline(pipeline_name)
+            self.sessions.active_pipeline = normalized
+            if normalized != _DEFAULT_PIPELINE:
+                pipeline_ctx = _build_pipeline_context(normalized)
+                if pipeline_ctx:
+                    system_prompt += "\n\n" + pipeline_ctx
+
+            def _stream_cb(event: dict) -> None:
+                event["session_id"] = session.session_id
+                self.events.push(event)
+
+            def _interrupt_check() -> bool:
+                return session.status in ("cancelled",)
+
+            _todo_token = current_store.set(session.todo_store)
+            self.events.chat_streaming = True
+
+            def _on_turn_complete() -> None:
+                self.sessions.persist_session(session)
+
+            try:
+                result: ConversationResult = await run_conversation_loop(
+                    llm_call=llm_call,
+                    system_prompt=system_prompt,
+                    messages=session.messages,
+                    tools=get_all_tools(),
+                    cdp_helpers=cdp_helpers,
+                    tools_dir=tools_dir,
+                    pipeline_name=normalized,
+                    interrupt_check=_interrupt_check,
+                    stream_callback=_stream_cb,
+                    on_turn_complete=_on_turn_complete,
+                )
+
+                session.status = "completed" if not result.interrupted else "cancelled"
+                session.budget_snapshot = result.budget.to_dict()
+
+                self.sessions.persist_session(session)
+
+                resp_preview = (result.final_response or "")[:120]
+                logger.info("Chat [%s] done: status=%s turns=%d duration=%dms response: %s",
+                            session.session_id, session.status,
+                            result.turn_count, result.duration_ms, resp_preview)
+
+                return {
+                    "ok": True,
+                    "response": result.final_response,
+                    "status": session.status,
+                    "turn_count": result.turn_count,
+                    "duration_ms": result.duration_ms,
+                }
+
+            except Exception as e:
+                logger.error("Chat processing error: %s", e)
+                session.status = "cancelled"
+                session.error_info = {"message": str(e)}
+                return {"ok": False, "error": str(e)}
+
+            finally:
+                self.events.chat_streaming = False
+                self.events.push({
+                    "type": "session.state",
+                    "status": session.status,
+                    "session_id": session.session_id,
+                })
+                current_store.reset(_todo_token)
+
+    # ── Pipeline management ─────────────────────────────────────────
+
+    def compile_pipeline(self, pipeline_text: str) -> dict:
+        """Compile pipeline.yaml text into step definitions."""
+        try:
+            from yak_browser_use.compiler.parser import parse_pipeline
+            from yak_browser_use.compiler.resolver import resolve
+            parsed = parse_pipeline(pipeline_text)
+            return resolve(parsed)
+        except Exception as e:
+            raise APIError(f"Failed to compile pipeline.yaml: {e}")
+
+    def list_presets(self) -> list[dict]:
+        """List saved pipelines from workspaces/."""
+        if not _WORKSPACES_DIR.exists():
+            return []
+        presets: list[dict] = []
+        for d in sorted(_WORKSPACES_DIR.iterdir()):
+            if not d.is_dir() or d.name.startswith("."):
+                continue
+            pipe_path = d / "pipeline.yaml"
+            if not pipe_path.exists():
+                continue
+            try:
+                presets.append({
+                    "name": d.name,
+                    "path": str(pipe_path),
+                    "modified": pipe_path.stat().st_mtime,
+                })
+            except Exception:
+                logger.warning("Failed to stat pipeline in %s", d, exc_info=True)
+        return presets
+
+    # ── Events (delegated) ─────────────────────────────────────────
+
+    def on_event(self, callback: Callable[[dict], None]) -> None:
+        """Register a callback for event streaming."""
+        self.events.on_event(callback)
+
+