lc-agent-app 0.2.1__py3-none-any.whl

lc_agent/__init__.py

@@ -0,0 +1,21 @@
+# lc_agent/__init__.py
+"""lc_agent — LangChain Agent framework with built-in Web UI."""
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("lc-agent-app")
+except PackageNotFoundError:
+    __version__ = "0.0.0-dev"
+
+from lc_agent.app import LcAgentApp
+from lc_agent.config.loader import load_config
+from lc_agent.tools.registry import ToolRegistry, tool
+
+__all__ = [
+    "LcAgentApp",
+    "load_config",
+    "ToolRegistry",
+    "tool",
+    "__version__",
+]

lc_agent/__main__.py

@@ -0,0 +1,4 @@
+from lc_agent.main import main
+
+if __name__ == "__main__":
+    main()

lc_agent/app.py

@@ -0,0 +1,194 @@
+# lc_agent/app.py
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+
+import uvicorn
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+
+from lc_agent.core.engine import AgentEngine
+from lc_agent.db.engine import init_db
+from lc_agent.server.app import create_app, mount_static_files
+from lc_agent.server.websocket import ChatWebSocketHandler
+
+
+class LcAgentApp:
+    """Main application orchestrator — creates engine, server, and runs."""
+
+    def __init__(self, config: dict, host: str = "127.0.0.1", port: int = 8000):
+        self.config = config
+        self.host = host
+        self.port = port
+        self._db_url = config.get("database", {}).get("url", "sqlite+aiosqlite:///./lc_agent_data.db")
+        self._checkpoint_path = config.get("database", {}).get("checkpoint_path", "./lc_agent_checkpoints.db")
+        self.engine = AgentEngine(config)
+        from lc_agent.skills.scanner import SkillScanner
+        skills_dir = config.get("skills", {}).get("directory", "./skills")
+        self.skill_scanner = SkillScanner(skills_dir)
+        self.skill_scanner.scan()
+        from lc_agent.mcp.manager import McpManager
+        mcp_config = config.get("mcp_servers", {})
+        self.mcp_manager = McpManager(mcp_config, on_state_change=self._on_mcp_state_change)
+        self.fastapi_app = create_app(config, lifespan=self._lifespan)
+        self.fastapi_app.state.mcp_manager = self.mcp_manager
+        self.fastapi_app.state.skill_scanner = self.skill_scanner
+        self.engine._skill_scanner = self.skill_scanner
+        self.engine._mcp_manager = self.mcp_manager
+        self.fastapi_app.state.engine = self.engine
+        self._ws_handler = ChatWebSocketHandler(self.engine, db_url=self._db_url)
+        self._setup_websocket_route()
+        mount_static_files(self.fastapi_app)
+
+    def _on_mcp_state_change(self):
+        self.engine._mcp_generation += 1
+
+    @asynccontextmanager
+    async def _lifespan(self, app: FastAPI):
+        """FastAPI lifespan: startup and shutdown logic."""
+        import asyncio
+
+        await init_db(self._db_url)
+        try:
+            from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+            import aiosqlite
+            conn = await aiosqlite.connect(self._checkpoint_path)
+            saver = AsyncSqliteSaver(conn)
+            await saver.setup()
+            self.engine._checkpointer = saver
+        except Exception as e:
+            print(f"[Warning] Checkpoint saver setup failed, using None: {e}")
+
+        await self._load_presets_from_db()
+
+        async def _connect_mcp_background():
+            try:
+                await self.mcp_manager.connect_all()
+                connected = [s for s in self.mcp_manager.servers if s.status == "connected"]
+                if connected:
+                    print(f"[MCP] Connected: {[s.name for s in connected]}")
+            except Exception as e:
+                print(f"[MCP] Background connection error: {e}")
+
+        asyncio.create_task(_connect_mcp_background())
+        try:
+            yield
+        finally:
+            await self.mcp_manager.shutdown()
+
+    def _setup_websocket_route(self):
+        import asyncio
+
+        async def _ws_loop(websocket: WebSocket, tid: str):
+            streaming_task: asyncio.Task | None = None
+            try:
+                while True:
+                    if streaming_task and not streaming_task.done():
+                        recv_coro = websocket.receive_json()
+                        recv_task = asyncio.ensure_future(recv_coro)
+                        done, _ = await asyncio.wait(
+                            [recv_task, streaming_task],
+                            return_when=asyncio.FIRST_COMPLETED,
+                        )
+                        if recv_task in done:
+                            data = recv_task.result()
+                            if data.get("type") == "cancel":
+                                self._ws_handler._cancel_flags[tid] = True
+                        if streaming_task in done:
+                            streaming_task = None
+                            if recv_task not in done:
+                                recv_task.cancel()
+                                try:
+                                    await recv_task
+                                except (asyncio.CancelledError, Exception):
+                                    pass
+                    else:
+                        data = await websocket.receive_json()
+                        msg_type = data.get("type", "message")
+                        if msg_type == "cancel":
+                            continue
+                        streaming_task = asyncio.create_task(
+                            self._ws_handler.handle_message(websocket, tid, data)
+                        )
+            except WebSocketDisconnect:
+                if streaming_task and not streaming_task.done():
+                    streaming_task.cancel()
+                await self._ws_handler.disconnect(tid)
+            except Exception as e:
+                print(f"[WS] Loop error: {e}")
+                if streaming_task and not streaming_task.done():
+                    streaming_task.cancel()
+                await self._ws_handler.disconnect(tid)
+
+        @self.fastapi_app.websocket("/ws/chat/{thread_id}")
+        async def websocket_chat(websocket: WebSocket, thread_id: str):
+            tid = await self._ws_handler.connect(websocket, thread_id)
+            await _ws_loop(websocket, tid)
+
+        @self.fastapi_app.websocket("/ws/chat")
+        async def websocket_chat_auto(websocket: WebSocket):
+            tid = await self._ws_handler.connect(websocket)
+            await _ws_loop(websocket, tid)
+
+    async def _load_presets_from_db(self):
+        """Load user-created presets from database on startup."""
+        from lc_agent.db.engine import get_async_session
+        from lc_agent.db.models import AgentPresetDB
+        from lc_agent.core.models import AgentPreset
+        from sqlalchemy import select
+
+        session = get_async_session(self._db_url)
+        try:
+            stmt = select(AgentPresetDB)
+            result = await session.execute(stmt)
+            for row in result.scalars().all():
+                preset = AgentPreset(
+                    id=row.id,
+                    name=row.name,
+                    system_prompt=row.system_prompt,
+                    default_model=row.default_model,
+                    allowed_tool_groups=row.allowed_tool_groups,
+                    allowed_mcp_servers=row.allowed_mcp_servers,
+                    allowed_skills=row.allowed_skills,
+                    dangerous_tools=row.dangerous_tools,
+                )
+                self.engine._presets[preset.id] = preset
+            loaded = len(self.engine._presets)
+            if loaded:
+                print(f"[Agents] Loaded {loaded} user presets from database")
+        except Exception as e:
+            print(f"[Warning] Failed to load presets from DB: {e}")
+        finally:
+            await session.close()
+
+    def add_agent(self, name: str, graph, description: str = ""):
+        """Register a pre-built CompiledStateGraph as a named agent.
+
+        Args:
+            name: Unique agent identifier
+            graph: A compiled LangGraph (must have ainvoke and astream_events)
+            description: Human-readable description
+        """
+        if name in self.engine._agents:
+            raise ValueError(f"Agent '{name}' already registered")
+
+        from lc_agent.core.models import AgentPreset
+
+        self.engine._agents[name] = graph
+        self.engine._agent_mcp_gen[name] = self.engine._mcp_generation
+        preset = AgentPreset(
+            id=name,
+            name=name,
+            system_prompt=description or f"Custom agent: {name}",
+            default_model="custom",
+            source="code",
+        )
+        self.engine._custom_presets[name] = preset
+
+    def run(self):
+        """Start the server (blocking)."""
+        from lc_agent import __version__
+
+        print(f"\n  lc_agent v{__version__}")
+        print(f"  Web UI: http://{self.host}:{self.port}")
+        print(f"  API Docs: http://{self.host}:{self.port}/api/docs\n")
+        uvicorn.run(self.fastapi_app, host=self.host, port=self.port)

lc_agent/config/__init__.py

@@ -0,0 +1,3 @@
+from lc_agent.config.loader import load_config, load_config_from_file, substitute_env_vars
+
+__all__ = ["load_config", "load_config_from_file", "substitute_env_vars"]

lc_agent/config/loader.py

@@ -0,0 +1,86 @@
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+import commentjson
+from dotenv import load_dotenv
+
+ENV_PATTERN = re.compile(r"\{env:([^}]+)\}")
+
+
+def substitute_env_vars(data: Any) -> Any:
+    """Recursively replace {env:VAR_NAME} patterns with environment variable values."""
+    if isinstance(data, str):
+        match = ENV_PATTERN.fullmatch(data)
+        if match:
+            var_name = match.group(1)
+            value = os.environ.get(var_name)
+            if value is None:
+                raise ValueError(f"Environment variable '{var_name}' not found")
+            return value
+        def replacer(m):
+            var_name = m.group(1)
+            value = os.environ.get(var_name)
+            if value is None:
+                raise ValueError(f"Environment variable '{var_name}' not found")
+            return value
+        return ENV_PATTERN.sub(replacer, data)
+    elif isinstance(data, dict):
+        return {k: substitute_env_vars(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [substitute_env_vars(item) for item in data]
+    return data
+
+
+def load_config_from_file(path: str) -> dict:
+    """Load a JSONC configuration file and apply env substitution."""
+    file_path = Path(path)
+    if not file_path.exists():
+        raise FileNotFoundError(f"Config file not found: {path}")
+
+    with open(file_path, "r", encoding="utf-8") as f:
+        raw = commentjson.load(f)
+
+    return substitute_env_vars(raw)
+
+
+def load_config(
+    config_path: str | None = None,
+    dotenv_path: str | None = None,
+) -> dict:
+    """Load configuration with priority: explicit path > ./config.jsonc > ~/.lc_agent/config.jsonc > defaults."""
+    if dotenv_path:
+        load_dotenv(dotenv_path)
+    else:
+        load_dotenv()
+
+    search_paths = []
+    if config_path:
+        search_paths.append(Path(config_path))
+    search_paths.append(Path.cwd() / "config.jsonc")
+    search_paths.append(Path.home() / ".lc_agent" / "config.jsonc")
+
+    for p in search_paths:
+        if p.exists():
+            config = load_config_from_file(str(p))
+            config["_config_path"] = str(p)
+            config["_project_root"] = str(p.parent)
+            return config
+
+    return {
+        "provider": {},
+        "agent": {
+            "system_prompt": "You are a helpful assistant.",
+            "default_model": "",
+            "streaming": True,
+        },
+        "database": {
+            "url": "sqlite+aiosqlite:///./lc_agent_data.db",
+            "checkpoint_path": "./lc_agent_checkpoints.db",
+        },
+        "skills": {"directory": "./skills"},
+        "mcp_servers": {},
+        "_config_path": None,
+        "_project_root": str(Path.cwd()),
+    }

lc_agent/config/schema.py

@@ -0,0 +1,48 @@
+from pydantic import BaseModel, Field
+
+
+class ModelConfig(BaseModel):
+    id: str
+    context_limit: int = 8000
+    max_output_tokens: int = 0
+
+
+class ProviderConfig(BaseModel):
+    api_key: str = ""
+    base_url: str = ""
+    models: list[ModelConfig] = Field(default_factory=list)
+
+
+class DatabaseConfig(BaseModel):
+    url: str = "sqlite+aiosqlite:///./lc_agent_data.db"
+    checkpoint_path: str = "./lc_agent_checkpoints.db"
+
+
+class SkillsConfig(BaseModel):
+    directory: str = "./skills"
+
+
+class McpServerConfig(BaseModel):
+    type: str = "local"  # "local", "sse", "http"
+    command: str | list[str] = ""
+    args: list[str] = Field(default_factory=list)
+    env: dict[str, str] = Field(default_factory=dict)
+    url: str = ""
+    enabled: bool = True
+
+
+class AppConfig(BaseModel):
+    """Application configuration schema."""
+
+    provider: dict[str, ProviderConfig | dict] = Field(default_factory=dict)
+    agent: dict = Field(default_factory=lambda: {
+        "system_prompt": "You are a helpful assistant.",
+        "default_model": "",
+        "streaming": True,
+    })
+    mcp: dict = Field(default_factory=dict)
+    database: DatabaseConfig = Field(default_factory=DatabaseConfig)
+    session: dict = Field(default_factory=lambda: {"db_path": ""})
+    ui: dict = Field(default_factory=dict)
+    skills: SkillsConfig = Field(default_factory=SkillsConfig)
+    mcp_servers: dict[str, McpServerConfig] = Field(default_factory=dict)

lc_agent/core/__init__.py

@@ -0,0 +1,5 @@
+# lc_agent/core/__init__.py
+from lc_agent.core.engine import AgentEngine
+from lc_agent.core.models import AgentPreset, ModelInfo
+
+__all__ = ["AgentEngine", "AgentPreset", "ModelInfo"]

lc_agent/core/chat_model.py

@@ -0,0 +1,48 @@
+"""ChatOpenAI subclass that extracts reasoning_content from streaming deltas.
+
+ChatOpenAI only supports official OpenAI API fields. Many providers (DeepSeek,
+GLM, etc.) return a non-standard `reasoning_content` field in the streaming
+delta for chain-of-thought / thinking content. This subclass captures it into
+`additional_kwargs["reasoning_content"]` so downstream handlers can display it.
+"""
+
+from __future__ import annotations
+
+from langchain_core.messages import AIMessageChunk
+from langchain_core.outputs import ChatGenerationChunk
+from langchain_openai import ChatOpenAI
+
+
+class ChatOpenAIReasoning(ChatOpenAI):
+    """ChatOpenAI with reasoning_content extraction from streaming deltas.
+
+    Drop-in replacement for ChatOpenAI. Works with any provider that returns
+    `reasoning_content` or `reasoning` in the streaming delta dict (e.g.
+    DeepSeek, GLM with thinking mode, OpenRouter).
+    """
+
+    def _convert_chunk_to_generation_chunk(
+        self,
+        chunk: dict,
+        default_chunk_class: type,
+        base_generation_info: dict | None,
+    ) -> ChatGenerationChunk | None:
+        generation_chunk = super()._convert_chunk_to_generation_chunk(
+            chunk, default_chunk_class, base_generation_info,
+        )
+        if generation_chunk is None:
+            return None
+
+        choices = chunk.get("choices") or chunk.get("chunk", {}).get("choices") or []
+        if not choices:
+            return generation_chunk
+
+        delta = choices[0].get("delta") or {}
+        if isinstance(generation_chunk.message, AIMessageChunk):
+            reasoning = delta.get("reasoning_content")
+            if reasoning is None:
+                reasoning = delta.get("reasoning")
+            if reasoning is not None:
+                generation_chunk.message.additional_kwargs["reasoning_content"] = reasoning
+
+        return generation_chunk