crow-task-mcp 0.1.26__tar.gz

crow_task_mcp-0.1.26/.gitignore

@@ -0,0 +1,36 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# keys
+.env
+
+# test database
+*.db
+*.db*
+
+# MyST build output
+docs/_build/
+_site/
+
+crow-editor/frontend/node_modules
+
+*.log
+*.log*
+
+
+crow-mcp/.venv
+crow-task-mcp/.venv
+crow-task-mcp/src/crow_task_mcp/__pycache__/
+crow-orchestrator-mcp/.venv
+crow-orchestrator-mcp/src/crow_orchestrator_mcp/__pycache__
+
+
+sandbox/lancedb-testing/pylate_lancedb/

crow_task_mcp-0.1.26/.python-version

@@ -0,0 +1 @@
+3.14

crow_task_mcp-0.1.26/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: crow-task-mcp
+Version: 0.1.26
+Summary: Orchestration tools for agent-to-agent communication via ACP protocol
+Requires-Python: >=3.14
+Requires-Dist: fastmcp>=3.4.2
+Description-Content-Type: text/markdown
+
+# crow-task-mcp
+
+Per-session orchestration tools — the "manage your own session" toolset that
+**every** agent (workers and orchestrators) loads.
+
+## Tools
+
+| Tool | Backend ext_method | Purpose |
+|------|-------------------|---------|
+| `send_prompt` | `_send` | Fire-and-forget prompt to another session. Returns immediately; retrieve the response later via `query_memory(session_id, limit=1)`. |
+| `task_read` | `_task/read` | Read this session's task list. |
+| `task_write` | `_task/write` | Create / update / delete tasks in this session's task list. |
+
+## Architecture
+
+These are **schema-only** definitions for the LLM (`raise NotImplementedError`).
+Real execution lives in `crow-cli`:
+
+1. `react.py` dispatches by bare tool name → `execute_orchestration_*` in `tools.py`
+2. `tools.py` calls `conn.ext_method(method=...)` over ACP
+3. The sidex client routes the ext_method to the `sidex-acp` backend
+4. Backend handler: `sidex/crates/sidex-acp/src/tools/orchestration_3.rs`
+
+> `task_send` (batch delegation + completion callback) is **not** here — it
+> lives in [`crow-orchestrator-mcp`](../crow-orchestrator-mcp) and is only
+> loaded by orchestrator agents. This keeps workers from advertising a
+> delegation tool they shouldn't use, and avoids a duplicate-tool-name
+> collision when an orchestrator loads both servers.
+
+## Run
+
+```bash
+uvx crow-task-mcp
+```

crow_task_mcp-0.1.26/README.md

@@ -0,0 +1,34 @@
+# crow-task-mcp
+
+Per-session orchestration tools — the "manage your own session" toolset that
+**every** agent (workers and orchestrators) loads.
+
+## Tools
+
+| Tool | Backend ext_method | Purpose |
+|------|-------------------|---------|
+| `send_prompt` | `_send` | Fire-and-forget prompt to another session. Returns immediately; retrieve the response later via `query_memory(session_id, limit=1)`. |
+| `task_read` | `_task/read` | Read this session's task list. |
+| `task_write` | `_task/write` | Create / update / delete tasks in this session's task list. |
+
+## Architecture
+
+These are **schema-only** definitions for the LLM (`raise NotImplementedError`).
+Real execution lives in `crow-cli`:
+
+1. `react.py` dispatches by bare tool name → `execute_orchestration_*` in `tools.py`
+2. `tools.py` calls `conn.ext_method(method=...)` over ACP
+3. The sidex client routes the ext_method to the `sidex-acp` backend
+4. Backend handler: `sidex/crates/sidex-acp/src/tools/orchestration_3.rs`
+
+> `task_send` (batch delegation + completion callback) is **not** here — it
+> lives in [`crow-orchestrator-mcp`](../crow-orchestrator-mcp) and is only
+> loaded by orchestrator agents. This keeps workers from advertising a
+> delegation tool they shouldn't use, and avoids a duplicate-tool-name
+> collision when an orchestrator loads both servers.
+
+## Run
+
+```bash
+uvx crow-task-mcp
+```

crow_task_mcp-0.1.26/pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "crow-task-mcp"
+version = "0.1.26"
+description = "Orchestration tools for agent-to-agent communication via ACP protocol"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "fastmcp>=3.4.2",
+]
+
+[project.scripts]
+crow-task-mcp = "crow_task_mcp.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

crow_task_mcp-0.1.26/src/crow_task_mcp/__init__.py

@@ -0,0 +1,11 @@
+"""
+Crow Task MCP - Orchestration tools for agent-to-agent communication.
+
+This package provides MCP tools for multi-agent workflows, enabling agents
+to coordinate by sending prompts, spawning child agents, and managing sessions.
+"""
+
+from .main import mcp
+
+__version__ = "0.1.0"
+__all__ = ["mcp"]

crow_task_mcp-0.1.26/src/crow_task_mcp/main.py

@@ -0,0 +1,152 @@
+"""
+Crow Task MCP - Orchestration tools for agent-to-agent communication.
+
+This MCP server provides tools that enable agents to coordinate with each other
+by sending prompts and managing tasks.
+
+Architecture:
+- Tools are defined here as schemas for the LLM
+- Actual execution happens in crow-cli/tools.py via ACP ext_method calls
+- The client (sidex) routes ext_method calls to sidex-acp backend
+- Backend methods: _send, _task/read, _task/write
+- task_send (_task/send) lives in crow-orchestrator-mcp, loaded only by orchestrators
+
+Note: Queue operations (_queue/*) are internal client logic and NOT exposed to agents.
+"""
+
+from fastmcp import FastMCP
+
+mcp = FastMCP("crow-task-mcp")
+
+
+@mcp.tool()
+def send_prompt(to_session_id: str, blocks: list[dict]) -> str:
+    """Send a prompt to another agent session.
+
+    The backend prompts the target session with your message blocks and
+    returns immediately. When the target finishes processing, you will
+    receive a notification telling you to call
+    `query_memory(session_id=<target_session_id>, limit=1)` to see the
+    result. On error, you will also be notified.
+
+    Args:
+        to_session_id: The session ID of the agent to send the message to.
+            This is a coolname-style slug, e.g.
+            "accurate-amethyst-salmon-from-vega".
+        blocks: Array of content blocks (text, image, etc.)
+
+    Returns:
+        Status message ("sent"); the result is delivered via a
+        completion notification, then fetched via query_memory
+    """
+    raise NotImplementedError(
+        "Orchestration tools are executed by crow-cli via ACP ext_method. "
+        "This schema is for LLM tool selection only."
+    )
+
+
+@mcp.tool()
+def task_read() -> dict:
+    """Read the task list for the current session.
+    
+    Returns:
+        Dictionary with tasks array and summary string
+    """
+    raise NotImplementedError(
+        "Orchestration tools are executed by crow-cli via ACP ext_method. "
+        "This schema is for LLM tool selection only."
+    )
+
+
+@mcp.tool()
+def task_write(todos: list[dict]) -> dict:
+    """Wholesale-replace the session's task list with a new set of todos.
+
+    This is your working memory AND your delegation mechanism for your future
+    self. Each call replaces the entire list — regenerate the full list with
+    updated statuses each time (like OpenCode's TodoWrite). No CRUD actions,
+    no action field.
+
+    ## How updating works
+
+    You always send the COMPLETE list, never a delta. To mark a task done,
+    copy the whole current list and change that one task's status to
+    "completed". To add a task, append it. To drop one, omit it. Every call
+    generates fresh IDs internally, so never try to address a task by its ID
+    across calls — just reproduce the list with the statuses you want.
+
+    ## How the list keeps the session going
+
+    The orchestration loop runs after each of your turns. It reads the list
+    and decides what to prompt you with next:
+
+      - If the current (in_progress) task is done, it promotes the next
+        pending task and hands it to you as your new focus.
+      - If the current task is NOT done at the end of a turn, you get
+        NAGGED: a message lists every still-incomplete task (pending or
+        in_progress) and tells you to call task_write to update statuses.
+        This nag fires every turn you leave work unfinished — it is the
+        loop's way of refusing to let you forget what is not done.
+      - The loop only stops (and the session only ends) when there are no
+        pending or in_progress tasks left — i.e. the list is empty or every
+        task is completed/failed/cancelled.
+
+    So the list is what keeps you alive and on-task: as long as there is
+    unfinished work in it, the loop will keep feeding you the next thing or
+    nagging you about what's left. An empty list is the only signal that the
+    session is truly done.
+
+    ## Delegate to your future self — one task per turn
+
+    The list lets you offload a large body of work onto your future self so
+    you can focus on the single task at hand. Lay out the whole plan up
+    front: a long list of many tasks, one marked "in_progress" and the rest
+    "pending". Then work ONLY on the in_progress task for that turn.
+
+    Do NOT try to burn through the entire list in a single turn. Do one
+    task, mark it "completed" via task_write, and end your turn. The loop
+    then promotes the next pending task and hands it to you as the new
+    focus — or, if you ended the turn with the current task still
+    incomplete, it nags you with the full list of unfinished work. This
+    turn-by-turn cadence is by design: it keeps each turn focused, keeps
+    context manageable, and lets the orchestration layer track real
+    progress instead of one giant turn. Let the nag/advance fire between
+    tasks; that is the mechanism doing its job.
+
+    ## Clearing the list when done
+
+    When a body of work is finished — all tasks are completed/failed/
+    cancelled and there is nothing left — write an empty list to clear it:
+
+        task_write(todos=[])
+
+    An empty list tells the orchestration layer the session is done. The
+    task loop exits, and if this session was delegated to via _task/send,
+    the caller is notified to pick up results. Completed tasks left sitting
+    in the list are noise — they make it harder to see what's pending and
+    they keep the loop alive when it should have exited. Don't accumulate
+    history; clear the list when the work is done.
+
+    Args:
+        todos: Array of todo objects, each with:
+            - content (required): Brief description of the task
+            - status: "pending", "in_progress", "completed", "failed", "cancelled"
+            - priority: "high", "medium", "low"
+            Pass an empty array to clear the list when all work is done.
+
+    Returns:
+        Dictionary with the updated tasks array
+    """
+    raise NotImplementedError(
+        "Orchestration tools are executed by crow-cli via ACP ext_method. "
+        "This schema is for LLM tool selection only."
+    )
+
+
+def main():
+    """Entry point for the MCP server."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()