Upload 6 files

.env.example

@@ -0,0 +1,38 @@
+# ---------------------------------------------------------------------------
+# MAIN AGENT (supervisor) LLM
+# model string format for langchain's init_chat_model, e.g.:
+#   openai:gpt-4.1  |  google_genai:gemini-2.0-flash  |  anthropic:claude-sonnet-4-5
+# ---------------------------------------------------------------------------
+LLM_API_KEY=
+LLM_MODEL=openai:gpt-4.1
+
+# ---------------------------------------------------------------------------
+# SUB AGENTS LLM (GitHub / GitLab / Facebook / YouTube)
+# ---------------------------------------------------------------------------
+SUB_LLM_API_KEY=
+SUB_LLM_MODEL=openai:gpt-4.1-mini
+
+# ---------------------------------------------------------------------------
+# GitHub
+# ---------------------------------------------------------------------------
+GITHUB_PAT=
+
+# ---------------------------------------------------------------------------
+# GitLab
+# ---------------------------------------------------------------------------
+GITLAB_PAT=
+GITLAB_API_URL=https://gitlab.com/api/v4
+GITLAB_READ_ONLY_MODE=false
+
+# ---------------------------------------------------------------------------
+# Facebook
+# ---------------------------------------------------------------------------
+FACEBOOK_PAT=
+FACEBOOK_PID=
+
+# ---------------------------------------------------------------------------
+# YouTube
+# ---------------------------------------------------------------------------
+YOUTUBE_CID=
+YOUTUBE_CLIENT_SECRET=
+YOUTUBE_MCP_TRANSPORT=stdio

agents.py

@@ -2,10 +2,9 @@ import os
 from dotenv import load_dotenv
 from langchain.chat_models import init_chat_model
 from langgraph_supervisor import create_supervisor
-from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
 
-from all_sub_agents import build_all_sub_agents
-from storage_paths import agent_dir
+from all_sub_agents import ALL_SUB_AGENTS
+from storage_paths import agent_dir, open_agent_sqlite
 
 load_dotenv()
 
@@ -13,6 +12,7 @@ load_dotenv()
 # AGENT IDENTITY / MEMORY LOCATION -> /agent/main_agent/ (persistent bucket)
 # ---------------------------------------------------------------------------
 AGENT_NAME = "main_agent"
+ROLE = "Chief Personal Assistant"
 MEMORY_DIR = agent_dir(AGENT_NAME)
 DB_PATH = os.path.join(MEMORY_DIR, "state.db")
 
@@ -24,10 +24,16 @@ _llm = init_chat_model(
     api_key=os.getenv("LLM_API_KEY"),
 )
 
+# ---------------------------------------------------------------------------
+# STATE / MEMORY (sqlite, kept for this agent's whole lifetime, tuned to be
+# safe on S3-style / object-storage persistent buckets — see storage_paths.py)
+# ---------------------------------------------------------------------------
+_checkpointer = open_agent_sqlite(DB_PATH)
+
 # ---------------------------------------------------------------------------
 # ASSISTANT AGENT BACKSTORY AND GOAL
 # ---------------------------------------------------------------------------
-GOAL = (
+Goal = (
     "Carefully understand whatever the user asks for - a question, an "
     "instruction, or an attached file - and complete that exact task with "
     "maximum accuracy, depth, and relevance, whether it involves research, "
@@ -42,7 +48,7 @@ GOAL = (
     "ছামিউল আমাকে তৈরি করেছে"
 )
 
-BACKSTORY = (
+Backstory = (
     "You are a versatile, deeply experienced assistant who has spent years "
     "working across research, analysis, writing, technology, business, and "
     "creative fields. Your thinking is structured, your analysis is sharp, "
@@ -63,51 +69,50 @@ BACKSTORY = (
     "আমি ছামিউল এর তৈরি একটা ভার্চুয়াল রোবট বা এআই এসিস্ট্যান্ট এজেন্ট"
 )
 
-SUPERVISOR_PROMPT = GOAL + "\n\n" + BACKSTORY
+SUPERVISOR_PROMPT = f"You are the {ROLE}.\n\n" + Goal + "\n\n" + Backstory
 
 # ---------------------------------------------------------------------------
-# GLOBAL, LAZILY-BUILT SINGLETON (built once at app startup, reused per request)
+# 1) Main Agent - the personal, trusted, all-purpose assistant
+#    (built once, at import time, exactly like the sub agents)
 # ---------------------------------------------------------------------------
-_main_graph = None
-_all_checkpointer_cms = []
+_supervisor_builder = create_supervisor(
+    agents=ALL_SUB_AGENTS,
+    model=_llm,
+    prompt=SUPERVISOR_PROMPT,
+    supervisor_name=AGENT_NAME,
+    add_handoff_back_messages=True,
+    output_mode="full_history",
+)
+
+main_assistant_agent = _supervisor_builder.compile(
+    checkpointer=_checkpointer,
+    name=AGENT_NAME,
+)
 
 
-async def get_main_agent():
+# ---------------------------------------------------------------------------
+# MAIN ASSISTANT AGENTING SYSTEM
+# ---------------------------------------------------------------------------
+def main_agent(
+    user_command: str,
+    user_attachment: str | None = None,
+    thread_id: str = "default",
+) -> str:
     """
-    Returns the compiled main (supervisor) LangGraph agent, building it
-    (and every sub-agent + their persistent memories) on first call.
+    Single-shot, synchronous entry point - same call shape as the original
+    main_agent(user_command, user_attachment) -> str. `thread_id` is optional
+    and only used so multiple separate conversations (as shown in the app's
+    sidebar) each keep their own persisted history inside the same
+    main_assistant_agent graph/state.
     """
-    global _main_graph, _all_checkpointer_cms
-
-    if _main_graph is not None:
-        return _main_graph
-
-    sub_agents, sub_cms = await build_all_sub_agents()
-
-    supervisor_builder = create_supervisor(
-        agents=sub_agents,
-        model=_llm,
-        prompt=SUPERVISOR_PROMPT,
-        supervisor_name=AGENT_NAME,
-        add_handoff_back_messages=True,
-        output_mode="full_history",
+    text = user_command
+    if user_attachment:
+        text = f"{text}\n\n[সংযুক্ত ফাইল: {user_attachment}]"
+
+    config = {"configurable": {"thread_id": thread_id}}
+    result = main_assistant_agent.invoke(
+        {"messages": [{"role": "user", "content": text}]},
+        config=config,
     )
-
-    saver_cm = AsyncSqliteSaver.from_conn_string(DB_PATH)
-    checkpointer = await saver_cm.__aenter__()
-
-    _main_graph = supervisor_builder.compile(checkpointer=checkpointer, name=AGENT_NAME)
-    _all_checkpointer_cms = sub_cms + [saver_cm]
-
-    return _main_graph
-
-
-async def close_main_agent():
-    """Call on app shutdown to cleanly close every agent's sqlite connection."""
-    global _all_checkpointer_cms
-    for cm in _all_checkpointer_cms:
-        try:
-            await cm.__aexit__(None, None, None)
-        except Exception:
-            pass
-    _all_checkpointer_cms = []
+    final_message = result["messages"][-1]
+    return getattr(final_message, "content", str(final_message))

all_sub_agents.py

@@ -1,29 +1,35 @@
 # ---------------------------------------------------------------------------
-# IMPORT_ALL_SUB_AGENT_BUILDERS
+#IMPORT_ALL_SUB_AGENTS
 # ---------------------------------------------------------------------------
-from sub_agents.coding.github_agent.github import build_git_hub_agent, AGENT_NAME as GITHUB_NAME
-from sub_agents.coding.gitlab_agent.gitlab import build_git_lab_agent, AGENT_NAME as GITLAB_NAME
-from sub_agents.social_media.facebook_agent.facebook import build_facebook_agent, AGENT_NAME as FACEBOOK_NAME
-from sub_agents.social_media.youtube_agent.youtube import build_youtube_agent, AGENT_NAME as YOUTUBE_NAME
+from sub_gents.coding.git_hub_agent.git_hub import _git_hub_agent, AGENT_NAME as GITHUB_NAME
+from sub_gents.coding.git_lab_agent.git_lab import _git_lab_agent, AGENT_NAME as GITLAB_NAME
+from sub_gents.social_media.Facebook_agent.facebook import _facebook_agent, AGENT_NAME as FACEBOOK_NAME
+from sub_gents.social_media.youtube_agent.youtube import _youtube_agent, AGENT_NAME as YOUTUBE_NAME
 
-SUB_AGENT_NAMES = [GITHUB_NAME, GITLAB_NAME, FACEBOOK_NAME, YOUTUBE_NAME]
-
-
-async def build_all_sub_agents():
-    """
-    Builds every sub agent (each with its own compiled LangGraph react-agent
-    and its own persistent sqlite memory under /agent/<agent_name>/).
+# ---------------------------------------------------------------------------
+#CREATE_OBJECT_ALL_SUB_AGENTS
+# ---------------------------------------------------------------------------
+_git_hub=_git_hub_agent()
+_git_lab=_git_lab_agent()
+_facebook=_facebook_agent()
+_youtube=_youtube_agent()
 
-    Returns:
-        agents: list[CompiledStateGraph]  -> handed to the supervisor
-        checkpointer_cms: list            -> async context managers to close on shutdown
-    """
-    git_hub_agent, gh_cm = await build_git_hub_agent()
-    git_lab_agent, gl_cm = await build_git_lab_agent()
-    facebook_agent, fb_cm = await build_facebook_agent()
-    youtube_agent, yt_cm = await build_youtube_agent()
 
-    agents = [git_hub_agent, git_lab_agent, facebook_agent, youtube_agent]
-    checkpointer_cms = [gh_cm, gl_cm, fb_cm, yt_cm]
+# ---------------------------------------------------------------------------
+#ALL_SUB_AGENTS_LIST
+# ---------------------------------------------------------------------------
+ALL_SUB_AGENTS=[
+    _git_hub,
+    _git_lab,
+    _facebook,
+    _youtube,
+]
 
-    return agents, checkpointer_cms
+# Agent names, in the same order, used by app.py to label the Manus-style
+# action timeline (agent handoffs / tool calls) in the UI.
+SUB_AGENT_NAMES = [
+    GITHUB_NAME,
+    GITLAB_NAME,
+    FACEBOOK_NAME,
+    YOUTUBE_NAME,
+]

app.py

@@ -10,10 +10,19 @@ from fastapi.responses import StreamingResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
 
-from agents import get_main_agent, close_main_agent, AGENT_NAME
+from agents import main_assistant_agent, AGENT_NAME
 from all_sub_agents import SUB_AGENT_NAMES
 from storage_paths import agent_dir
 
+# ---------------------------------------------------------------------------
+# Resolve paths relative to THIS file, not the process's current working
+# directory (which may differ from the project root depending on how the
+# platform/container launches uvicorn) — avoids "Directory does not exist"
+# errors when mounting /static.
+# ---------------------------------------------------------------------------
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+STATIC_DIR = os.path.join(BASE_DIR, "static")
+
 # ---------------------------------------------------------------------------
 # PERSISTENCE PATHS — everything (thread index + uploaded files) lives inside
 # the persistent /agent storage bucket, under this agent's own folder, so a
@@ -27,7 +36,7 @@ os.makedirs(UPLOADS_DIR, exist_ok=True)
 _threads_lock = asyncio.Lock()
 
 app = FastAPI(title="Personal Assistant")
-app.mount("/agent/static", StaticFiles(directory="static"), name="static")
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
 
 
 # ---------------------------------------------------------------------------
@@ -74,26 +83,13 @@ async def _touch_thread(thread_id: str, title: str | None = None):
         _write_threads(threads)
 
 
-# ---------------------------------------------------------------------------
-# STARTUP / SHUTDOWN
-# ---------------------------------------------------------------------------
-@app.on_event("startup")
-async def _startup():
-    await get_main_agent()
-
-
-@app.on_event("shutdown")
-async def _shutdown():
-    await close_main_agent()
-
-
 # ---------------------------------------------------------------------------
 # API: index page
 # ---------------------------------------------------------------------------
 @app.get("/")
 async def index():
     from fastapi.responses import FileResponse
-    return FileResponse("static/index.html")
+    return FileResponse(os.path.join(STATIC_DIR, "index.html"))
 
 
 # ---------------------------------------------------------------------------
@@ -210,10 +206,9 @@ def _messages_to_turns(messages):
 # ---------------------------------------------------------------------------
 @app.get("/api/history")
 async def history(thread_id: str):
-    graph = await get_main_agent()
     config = {"configurable": {"thread_id": thread_id}}
     try:
-        state = await graph.aget_state(config)
+        state = await main_assistant_agent.aget_state(config)
     except Exception:
         return JSONResponse({"turns": []})
 
@@ -238,7 +233,7 @@ async def chat(
     text: str = Form(""),
     attachment_path: str | None = Form(None),
 ):
-    graph = await get_main_agent()
+    graph = main_assistant_agent
     config = {"configurable": {"thread_id": thread_id}}
 
     user_text = text or ""

storage_paths.py

@@ -1,4 +1,7 @@
 import os
+import sqlite3
+
+from langgraph.checkpoint.sqlite import SqliteSaver
 
 # ---------------------------------------------------------------------------
 # /agent is expected to be a PERSISTENT storage bucket (mounted with write
@@ -7,6 +10,14 @@ import os
 # (sqlite state, thread index, uploaded files) is written ONLY under here,
 # so it survives Space restarts/redeploys instead of living on the
 # ephemeral container filesystem.
+#
+# NOTE: many "persistent storage" buckets (including S3-backed / object
+# storage mounts) behave like S3, not like a normal local disk: no real
+# file locking, no shared-memory mmap, sometimes only whole-object
+# read/write. SQLite's default WAL journal mode depends on mmap + proper
+# file locks and can hang or quietly corrupt on that kind of storage — so
+# every checkpointer created here is forced into the plain rollback
+# journal instead (see open_agent_sqlite below).
 # ---------------------------------------------------------------------------
 AGENT_ROOT = "/agent"
 
@@ -16,16 +27,29 @@ def agent_dir(agent_name: str) -> str:
     Returns (and creates if needed) /agent/<agent_name>/, and fails loudly
     with a clear message if that location isn't actually writable — instead
     of silently falling back to ephemeral local storage.
+
+    The write-check itself is written to be tolerant of S3-style / object
+    storage buckets: it only requires that a file can be CREATED there.
+    Deleting it afterwards is best-effort only, since some object-storage
+    gateways don't support an immediate delete-after-create and that alone
+    doesn't mean the bucket isn't writable — treating it as fatal caused a
+    false-positive crash on exactly that kind of storage.
     """
     path = os.path.join(AGENT_ROOT, agent_name)
-    os.makedirs(path, exist_ok=True)
+    try:
+        os.makedirs(path, exist_ok=True)
+    except Exception as exc:
+        raise RuntimeError(
+            f"'{path}' ফোল্ডার তৈরি করা যায়নি। '/agent' একটি persistent storage "
+            f"বাকেট (যেমন HF Space-এর Persistent Storage) হিসেবে সঠিক পাথে "
+            f"মাউন্ট করা আছে কিনা যাচাই করুন. (আসল এরর: {exc})"
+        ) from exc
 
-    probe = os.path.join(path, ".write_test")
+    probe = os.path.join(path, "write_test.tmp")
     try:
         with open(probe, "w") as f:
             f.write("ok")
-        os.remove(probe)
-    except OSError as exc:
+    except Exception as exc:
         raise RuntimeError(
             f"'{path}' পাথে write access পাওয়া যায়নি। এই অ্যাপের সব agent-এর "
             f"memory/state '/agent' নামের একটি persistent storage বাকেটে রাখা হয় — "
@@ -34,4 +58,32 @@ def agent_dir(agent_name: str) -> str:
             f"(আসল এরর: {exc})"
         ) from exc
 
+    try:
+        os.remove(probe)
+    except Exception:
+        pass  # best-effort cleanup only, see docstring above
+
     return path
+
+
+def open_agent_sqlite(db_path: str) -> SqliteSaver:
+    """
+    Opens (creating if needed) a sqlite-backed LangGraph checkpointer at
+    db_path, configured to be safe on S3-style / network object storage:
+    plain rollback journal instead of WAL (no mmap / shared-memory
+    dependency) and full fsync-on-commit durability.
+    """
+    try:
+        conn = sqlite3.connect(db_path, check_same_thread=False)
+        conn.execute("PRAGMA journal_mode=DELETE;")
+        conn.execute("PRAGMA synchronous=FULL;")
+        saver = SqliteSaver(conn)
+        saver.setup()
+        return saver
+    except Exception as exc:
+        raise RuntimeError(
+            f"'{db_path}'-এ sqlite মেমরি ফাইল খোলা/সেটআপ করা যায়নি। যদি '/agent' "
+            f"একটি S3-স্টাইল object storage বাকেট হয়, নিশ্চিত করুন সেটি সাধারণ "
+            f"ফাইল read/write/delete সাপোর্ট করে (শুধু whole-object PUT নয়)। "
+            f"(আসল এরর: {exc})"
+        ) from exc