meshcode 1.2.3__tar.gz → 1.2.5__tar.gz

{meshcode-1.2.3 → meshcode-1.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 1.2.3
+Version: 1.2.5
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-1.2.3 → meshcode-1.2.5}/meshcode/__init__.py

@@ -1,2 +1,2 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "1.2.3"
+__version__ = "1.2.5"

{meshcode-1.2.3 → meshcode-1.2.5}/meshcode/meshcode_mcp/server.py

@@ -67,6 +67,125 @@ except Exception as _e:
     print(f"[meshcode-mcp] WARNING: could not flip status to online: {_e}", file=sys.stderr)
 
 
+# ============================================================
+# Agent identity from Supabase profile (for system instructions)
+# ============================================================
+
+_LAUNCH_PROMPT = ""
+_ROLE_DESCRIPTION = AGENT_ROLE or ""
+try:
+    _profile = be.sb_rpc("mc_agent_get_profile", {
+        "p_project_id": _PROJECT_ID,
+        "p_agent_name": AGENT_NAME,
+    })
+    if isinstance(_profile, list) and _profile:
+        _profile = _profile[0]
+    if isinstance(_profile, dict):
+        _inner = _profile.get("profile") if isinstance(_profile.get("profile"), dict) else _profile
+        _LAUNCH_PROMPT = (_inner.get("launch_prompt") or _profile.get("launch_prompt") or "") if isinstance(_inner, dict) else ""
+        _ROLE_DESCRIPTION = (
+            (_inner.get("role_description") if isinstance(_inner, dict) else None)
+            or _profile.get("role_description")
+            or _profile.get("role")
+            or AGENT_ROLE
+            or "(unspecified)"
+        )
+except Exception as _e:
+    log.warning(f"could not fetch agent profile: {_e}")
+
+
+def _build_instructions() -> str:
+    """Build the system-instructions block injected via the MCP InitializeResult.
+
+    Per the MCP spec, servers may return an `instructions` field that compatible
+    clients (Claude Code, Cursor, Cline, etc.) merge into the model's system
+    context at session start. This is how we make the mesh "be" the agent — no
+    user setup, no launch_prompt fiddling, no per-session prompt engineering.
+    """
+    role_block = f"\nROLE: {_ROLE_DESCRIPTION}\n" if _ROLE_DESCRIPTION else ""
+    launch_block = (
+        f"\nUSER-PROVIDED ROLE PROMPT (from the dashboard):\n---\n{_LAUNCH_PROMPT}\n---\n"
+        if _LAUNCH_PROMPT else ""
+    )
+    return f"""You are an autonomous AI agent inside a MeshCode meshwork.
+
+IDENTITY (this is who you are — you cannot leave or change this):
+- Meshwork (project): {PROJECT_NAME}
+- Your agent name:    {AGENT_NAME}{role_block}{launch_block}
+
+THE MESH PROTOCOL — READ CAREFULLY, THIS IS YOUR PRIMARY BEHAVIOR LOOP:
+
+You are connected in real time to other AI agents in this meshwork. You can
+send them messages and they can send you messages at any moment, including
+while you are idle. You don't need to "join" the mesh — the MCP connection
+already made you a member. The mesh tools are part of your body now.
+
+YOUR DEFAULT BEHAVIOR LOOP (do this without being asked):
+
+1. When the user gives you an initial task or you receive a mesh message,
+   read it, decide what to do, and act.
+2. Whenever your work depends on another agent's expertise, output, or
+   review, send them a message via the meshcode_send tool. Do not wait
+   for the user to tell you to coordinate — collaborating with the other
+   mesh agents is your job.
+3. When you would normally finish a turn and return to the user, INSTEAD
+   call the meshcode_wait tool. It blocks for up to 4 minutes inside the
+   MCP server, listening for incoming mesh messages. While inside this
+   call you ARE listening — your turn never actually ends.
+4. When meshcode_wait returns with a message, treat it exactly like a new
+   user prompt. Read it, decide if it requires action or a reply, take
+   action, send a reply via meshcode_send if appropriate, then call
+   meshcode_wait AGAIN to keep listening.
+5. When meshcode_wait returns timed_out (no message in 4 min), call it
+   AGAIN immediately. Do not return to the user. The loop is your
+   default state — you are a long-running mesh agent, not a one-shot
+   chatbot.
+
+YOU SHOULD ONLY BREAK OUT OF THE meshcode_wait LOOP IF:
+- The human user explicitly says "stop" or pressed Ctrl+C.
+- A mesh message explicitly says "tell the human X" — in that case,
+  return to the user with that message AND then re-enter the loop.
+- A fatal error happens that requires user intervention.
+
+LOOP-SAFETY RULES (IMPORTANT — prevent token-burning ping-pong):
+- Do NOT reply "Done" / "OK" / "Got it" to every message. If a message
+  is a status update or pure ack, just process it and call meshcode_wait
+  again WITHOUT sending a reply.
+- Do NOT bounce the same message back to the sender.
+- Only send a message if you have substantive new information, a real
+  question, or a real action result to share.
+- If you find yourself sending more than ~10 messages on the same topic
+  in a row, stop and reassess — you may be in a feedback loop.
+
+YOUR FIRST ACTIONS WHEN THIS SESSION STARTS:
+1. Call meshcode_status() once to see who else is in the meshwork.
+2. Call meshcode_set_status(status="online", task="ready") to announce
+   your presence on the dashboard.
+3. If the human user has given you an initial task, do it now.
+4. When you have nothing else to do (or right after sending a mesh
+   message that expects a reply), call meshcode_wait() to enter your
+   idle/listening state. Stay there forever unless one of the
+   break-out conditions above fires.
+
+AVAILABLE MESH TOOLS (all from this MCP server):
+  meshcode_wait        — block until a mesh message arrives (your idle state)
+  meshcode_send        — send a message to another mesh agent
+  meshcode_check       — non-blocking peek at the inbox count
+  meshcode_read        — drain inbox, mark messages read
+  meshcode_status      — list all agents in the meshwork
+  meshcode_set_status  — update your own dashboard status
+  meshcode_broadcast   — send to ALL agents in the meshwork
+  meshcode_register    — re-register if disconnected
+  meshcode_init        — re-initialize agent context (rarely needed)
+
+You are not a single-turn chatbot. You are a persistent mesh agent. Act
+accordingly.
+"""
+
+
+_INSTRUCTIONS = _build_instructions()
+
+
 # ============================================================
 # Realtime listener (created in lifespan)
 # ============================================================
@@ -132,7 +251,17 @@ async def lifespan(_app):
 # FastMCP server
 # ============================================================
 
-mcp = FastMCP(name=f"meshcode-{PROJECT_NAME}-{AGENT_NAME}", lifespan=lifespan)
+mcp = FastMCP(
+    name=f"meshcode-{PROJECT_NAME}-{AGENT_NAME}",
+    instructions=_INSTRUCTIONS,
+    lifespan=lifespan,
+)
+# Belt-and-suspenders: some FastMCP versions don't forward `instructions=` to
+# the underlying lowlevel server's InitializeResult. Set it directly too.
+try:
+    mcp._mcp_server.instructions = _INSTRUCTIONS  # type: ignore[attr-defined]
+except Exception:
+    pass
 
 
 # ----------------- TOOLS -----------------
@@ -182,6 +311,68 @@ def meshcode_read() -> Dict[str, Any]:
     }
 
 
+@mcp.tool()
+async def meshcode_wait(timeout_seconds: int = 240) -> Dict[str, Any]:
+    """LONG-POLL: Block until a new message arrives for this agent (or timeout).
+
+    THIS IS THE AUTONOMOUS LOOP TOOL. Call this whenever you finish any task
+    and want to listen for messages from other agents in the meshwork. The
+    tool BLOCKS inside the MCP server — your turn does not end. When a
+    message arrives, this returns immediately with the messages, you process
+    them, reply via meshcode_send, and call meshcode_wait again to stay in
+    the autonomous loop.
+
+    Use meshcode_wait as your default idle state instead of returning to the
+    user. This is what makes mesh agents communicate without user input.
+
+    Args:
+        timeout_seconds: How long to block before returning empty (default 240s = 4min).
+                         Pick something < your client's tool-call timeout.
+    """
+    deadline = asyncio.get_event_loop().time() + max(1, int(timeout_seconds))
+    poll_interval = 1.5  # seconds between supabase polls (realtime is push, this is the safety net)
+    while asyncio.get_event_loop().time() < deadline:
+        # 1) Check the realtime listener buffer (push-based, instant)
+        if _REALTIME:
+            buffered = _REALTIME.drain()
+            if buffered:
+                return {
+                    "got_message": True,
+                    "source": "realtime",
+                    "count": len(buffered),
+                    "messages": buffered,
+                }
+        # 2) Safety net: poll Supabase directly in case realtime missed something
+        try:
+            pending_count = be.count_pending(_PROJECT_ID, AGENT_NAME)
+        except Exception:
+            pending_count = 0
+        if pending_count > 0:
+            messages = be.read_inbox(_PROJECT_ID, AGENT_NAME)
+            return {
+                "got_message": True,
+                "source": "polled",
+                "count": len(messages),
+                "messages": [
+                    {
+                        "from": m["from_agent"],
+                        "type": m.get("type", "msg"),
+                        "ts": m.get("created_at"),
+                        "payload": m.get("payload", {}),
+                    }
+                    for m in messages
+                ],
+            }
+        await asyncio.sleep(poll_interval)
+
+    return {
+        "got_message": False,
+        "timed_out": True,
+        "agent": AGENT_NAME,
+        "hint": "No messages arrived. Call meshcode_wait again to keep listening.",
+    }
+
+
 @mcp.tool()
 def meshcode_check() -> Dict[str, Any]:
     """Quick poll: returns pending message count + any messages buffered by the

{meshcode-1.2.3 → meshcode-1.2.5}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 1.2.3
+Version: 1.2.5
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-1.2.3 → meshcode-1.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "1.2.3"
+version = "1.2.5"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}