agent-dispatch 0.2.0__tar.gz → 0.2.2__tar.gz

{agent_dispatch-0.2.0 → agent_dispatch-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-dispatch
-Version: 0.2.0
+Version: 0.2.2
 Summary: MCP server that lets Claude Code agents delegate tasks to agents in other project directories
 Project-URL: Homepage, https://github.com/ginkida/agent-dispatch
 Project-URL: Repository, https://github.com/ginkida/agent-dispatch

{agent_dispatch-0.2.0 → agent_dispatch-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-dispatch"
-version = "0.2.0"
+version = "0.2.2"
 description = "MCP server that lets Claude Code agents delegate tasks to agents in other project directories"
 readme = "README.md"
 license = "MIT"

{agent_dispatch-0.2.0 → agent_dispatch-0.2.2}/src/agent_dispatch/__init__.py

@@ -1,3 +1,3 @@
 """agent-dispatch: Delegate tasks between Claude Code agents across projects."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"

{agent_dispatch-0.2.0 → agent_dispatch-0.2.2}/src/agent_dispatch/cli.py

@@ -8,11 +8,31 @@ import subprocess
 from pathlib import Path
 
 import click
+import yaml
+from pydantic import ValidationError
 
 from .config import auto_describe, config_path, load_config, save_config
 from .models import AgentConfig, DispatchConfig, check_permission_mode, validate_agent_name
 
 
+def _load_or_exit() -> DispatchConfig:
+    """Load config, exiting with a friendly error on malformed YAML or schema."""
+    try:
+        return load_config()
+    except ValidationError as e:
+        click.echo(click.style(
+            f"Error: config at {config_path()} has an invalid schema:", fg="red"
+        ))
+        click.echo(str(e))
+        raise SystemExit(1)
+    except yaml.YAMLError as e:
+        click.echo(click.style(
+            f"Error: config at {config_path()} is not valid YAML:", fg="red"
+        ))
+        click.echo(str(e))
+        raise SystemExit(1)
+
+
 @click.group()
 @click.version_option(package_name="agent-dispatch")
 def cli() -> None:
@@ -107,7 +127,7 @@ def add(
         click.echo(f"Error: {e}")
         raise SystemExit(1)
 
-    config = load_config()
+    config = _load_or_exit()
     dir_path = Path(directory).resolve()
 
     if name in config.agents:
@@ -126,9 +146,9 @@ def add(
         max_budget_usd=max_budget,
         permission_mode=permission_mode,
         allowed_tools=[t.strip() for t in allowed_tools.split(",") if t.strip()]
-        if allowed_tools else [],
+        if allowed_tools else None,
         disallowed_tools=[t.strip() for t in disallowed_tools.split(",") if t.strip()]
-        if disallowed_tools else [],
+        if disallowed_tools else None,
     )
     if warning := check_permission_mode(permission_mode):
         click.echo(click.style(f"Warning: {warning}", fg="yellow"))
@@ -141,7 +161,7 @@ def add(
 @click.argument("name")
 def remove(name: str) -> None:
     """Remove an agent."""
-    config = load_config()
+    config = _load_or_exit()
     if name not in config.agents:
         click.echo(f"Agent '{name}' not found.")
         raise SystemExit(1)
@@ -154,14 +174,20 @@ def remove(name: str) -> None:
 @cli.command("list")
 def list_agents() -> None:
     """List configured agents with health status."""
-    config = load_config()
+    config = _load_or_exit()
     if not config.agents:
         click.echo("No agents configured. Run: agent-dispatch add <name> <directory>")
         return
 
     for name, agent in config.agents.items():
-        healthy = agent.directory.is_dir()
-        status = click.style("OK", fg="green") if healthy else click.style("NOT FOUND", fg="red")
+        try:
+            healthy = agent.directory.is_dir()
+            status_label = "OK" if healthy else "NOT FOUND"
+            status_color = "green" if healthy else "red"
+        except OSError:
+            status_label = "UNREADABLE"
+            status_color = "red"
+        status = click.style(status_label, fg=status_color)
         click.echo(f"  {name} [{status}]")
         click.echo(f"    dir:  {agent.directory}")
         click.echo(f"    desc: {agent.description}")
@@ -176,10 +202,12 @@ def list_agents() -> None:
             click.echo(f"    config: {', '.join(extras)}")
         if agent.permission_mode:
             click.echo(f"    permission_mode: {agent.permission_mode}")
-        if agent.allowed_tools:
-            click.echo(f"    allowed_tools: {', '.join(agent.allowed_tools)}")
-        if agent.disallowed_tools:
-            click.echo(f"    disallowed_tools: {', '.join(agent.disallowed_tools)}")
+        if agent.allowed_tools is not None:
+            rendered = ", ".join(agent.allowed_tools) if agent.allowed_tools else "(none)"
+            click.echo(f"    allowed_tools: {rendered}")
+        if agent.disallowed_tools is not None:
+            rendered = ", ".join(agent.disallowed_tools) if agent.disallowed_tools else "(none)"
+            click.echo(f"    disallowed_tools: {rendered}")
         click.echo()
 
 
@@ -214,7 +242,7 @@ def update(
     disallowed_tools: str | None,
 ) -> None:
     """Update an existing agent's configuration."""
-    config = load_config()
+    config = _load_or_exit()
     if name not in config.agents:
         click.echo(f"Agent '{name}' not found. Run 'agent-dispatch list' to see agents.")
         raise SystemExit(1)
@@ -229,26 +257,27 @@ def update(
         agent.timeout = timeout
         updated.append("timeout")
     if model is not None:
-        agent.model = None if model.lower() == "none" else model
+        agent.model = None if model.strip().lower() in ("none", "") else model
         updated.append("model")
     if max_budget is not None:
         agent.max_budget_usd = None if max_budget == 0 else max_budget
         updated.append("max_budget_usd")
     if permission_mode is not None:
-        effective = None if permission_mode.lower() == "none" else permission_mode
+        stripped = permission_mode.strip()
+        effective = None if stripped.lower() in ("none", "") else stripped
         agent.permission_mode = effective
         if warning := check_permission_mode(effective):
             click.echo(click.style(f"Warning: {warning}", fg="yellow"))
         updated.append("permission_mode")
     if allowed_tools is not None:
-        if allowed_tools.lower() == "none":
-            agent.allowed_tools = []
+        if allowed_tools.strip().lower() in ("none", ""):
+            agent.allowed_tools = None
         else:
             agent.allowed_tools = [t.strip() for t in allowed_tools.split(",") if t.strip()]
         updated.append("allowed_tools")
     if disallowed_tools is not None:
-        if disallowed_tools.lower() == "none":
-            agent.disallowed_tools = []
+        if disallowed_tools.strip().lower() in ("none", ""):
+            agent.disallowed_tools = None
         else:
             agent.disallowed_tools = [
                 t.strip() for t in disallowed_tools.split(",") if t.strip()
@@ -268,7 +297,7 @@ def update(
 @click.argument("task", default="What project is this? Describe in one sentence.")
 def test(name: str, task: str) -> None:
     """Test an agent by dispatching a task."""
-    config = load_config()
+    config = _load_or_exit()
     if name not in config.agents:
         click.echo(f"Agent '{name}' not found. Run 'agent-dispatch list' to see agents.")
         raise SystemExit(1)

{agent_dispatch-0.2.0 → agent_dispatch-0.2.2}/src/agent_dispatch/models.py

@@ -15,14 +15,24 @@ KNOWN_PERMISSION_MODES = frozenset({
 
 def check_permission_mode(mode: str | None) -> str | None:
     """Return a warning message if mode is unknown, else None."""
-    if mode and mode not in KNOWN_PERMISSION_MODES:
+    if not mode:
+        return None
+    trimmed = mode.strip()
+    if not trimmed:
+        return None
+    if trimmed not in KNOWN_PERMISSION_MODES:
         known = ", ".join(sorted(KNOWN_PERMISSION_MODES))
-        return f"Unknown permission_mode: {mode!r}. Known values: {known}"
+        return f"Unknown permission_mode: {trimmed!r}. Known values: {known}"
     return None
 
 
 class AgentConfig(BaseModel):
-    """Configuration for a single agent."""
+    """Configuration for a single agent.
+
+    `allowed_tools` / `disallowed_tools` use `None` to mean
+    "inherit from settings.default_*" and `[]` to mean "explicitly empty
+    (override defaults to no tools)".
+    """
 
     directory: Path
     description: str = ""
@@ -30,8 +40,8 @@ class AgentConfig(BaseModel):
     max_budget_usd: float | None = None
     model: str | None = None
     permission_mode: str | None = None
-    allowed_tools: list[str] = Field(default_factory=list)
-    disallowed_tools: list[str] = Field(default_factory=list)
+    allowed_tools: list[str] | None = None
+    disallowed_tools: list[str] | None = None
 
     @field_validator("directory", mode="before")
     @classmethod

{agent_dispatch-0.2.0 → agent_dispatch-0.2.2}/src/agent_dispatch/runner.py

@@ -29,9 +29,14 @@ _PERMISSION_PATTERNS = [
 ]
 
 
-def _classify_error(error_text: str) -> str:
-    """Classify an error message into a category."""
-    lower = error_text.lower()
+def _classify_error(error_text: object) -> str:
+    """Classify an error message into a category.
+
+    Accepts any type and coerces to string — some claude CLI error paths
+    produce non-string values (None, dict) that would crash `.lower()`.
+    """
+    text = str(error_text) if error_text else ""
+    lower = text.lower()
     for pattern in _PERMISSION_PATTERNS:
         if pattern in lower:
             return "permission"
@@ -101,11 +106,18 @@ def _build_command(
     if permission_mode:
         cmd.extend(["--permission-mode", permission_mode])
 
-    allowed = agent.allowed_tools or settings.default_allowed_tools
+    # None = inherit from settings; [] = explicitly empty (no inheritance)
+    allowed = (
+        agent.allowed_tools if agent.allowed_tools is not None
+        else settings.default_allowed_tools
+    )
     for tool in allowed:
         cmd.extend(["--allowedTools", tool])
 
-    disallowed = agent.disallowed_tools or settings.default_disallowed_tools
+    disallowed = (
+        agent.disallowed_tools if agent.disallowed_tools is not None
+        else settings.default_disallowed_tools
+    )
     for tool in disallowed:
         cmd.extend(["--disallowedTools", tool])
 
@@ -227,22 +239,36 @@ def dispatch(
         data = json.loads(proc.stdout)
     except json.JSONDecodeError:
         # Fallback: treat stdout as plain text
+        success = proc.returncode == 0
+        text = proc.stdout.strip()
+        if success:
+            return DispatchResult(agent=agent_name, success=True, result=text)
+        error_text = text or f"claude exited with code {proc.returncode} (non-JSON output)"
+        error_type = _classify_error(error_text)
+        if error_type == "permission":
+            error_text += _permission_hint(agent_name)
         return DispatchResult(
             agent=agent_name,
-            success=proc.returncode == 0,
-            result=proc.stdout.strip(),
+            success=False,
+            result=text,
+            error=error_text,
+            error_type=error_type,
         )
 
     is_error = data.get("is_error", False)
     if is_error:
-        error_text = data.get("result", "")
+        raw_result = data.get("result", "")
+        error_text = str(raw_result) if raw_result else (
+            f"Agent '{agent_name}' reported an error with no details "
+            f"(exit code {proc.returncode})"
+        )
         error_type = _classify_error(error_text)
         if error_type == "permission":
             error_text += _permission_hint(agent_name)
         return DispatchResult(
             agent=agent_name,
             success=False,
-            result=data.get("result", ""),
+            result=str(raw_result) if raw_result else "",
             session_id=data.get("session_id"),
             cost_usd=data.get("total_cost_usd"),
             duration_ms=data.get("duration_ms"),
@@ -326,11 +352,21 @@ def dispatch_stream(
             text=True,
             env=env,
         )
-    except OSError as e:
+    except FileNotFoundError as e:
         return DispatchResult(
             agent=agent_name, success=False, result="", error=str(e),
             error_type="not_found",
         )
+    except PermissionError as e:
+        return DispatchResult(
+            agent=agent_name, success=False, result="", error=str(e),
+            error_type="permission",
+        )
+    except OSError as e:
+        return DispatchResult(
+            agent=agent_name, success=False, result="", error=str(e),
+            error_type="cli_error",
+        )
 
     # Kill the process if it exceeds the timeout
     timed_out = threading.Event()
@@ -387,14 +423,17 @@ def dispatch_stream(
     if result_data:
         is_error = result_data.get("is_error", False)
         if is_error:
-            error_text = result_data.get("result", "")
+            raw_result = result_data.get("result", "")
+            error_text = str(raw_result) if raw_result else (
+                f"Agent '{agent_name}' reported an error with no details"
+            )
             error_type = _classify_error(error_text)
             if error_type == "permission":
                 error_text += _permission_hint(agent_name)
             return DispatchResult(
                 agent=agent_name,
                 success=False,
-                result=result_data.get("result", ""),
+                result=str(raw_result) if raw_result else "",
                 session_id=result_data.get("session_id"),
                 cost_usd=result_data.get("total_cost_usd"),
                 duration_ms=result_data.get("duration_ms"),

{agent_dispatch-0.2.0 → agent_dispatch-0.2.2}/src/agent_dispatch/server.py

@@ -113,9 +113,10 @@ async def list_agents(ctx: Context | None = None) -> str:
         }
         if agent.permission_mode:
             entry["permission_mode"] = agent.permission_mode
-        if agent.allowed_tools:
+        # Include when explicitly set (even []) to distinguish from inheriting defaults
+        if agent.allowed_tools is not None:
             entry["allowed_tools"] = agent.allowed_tools
-        if agent.disallowed_tools:
+        if agent.disallowed_tools is not None:
             entry["disallowed_tools"] = agent.disallowed_tools
         agents.append(entry)
     if ctx:
@@ -326,6 +327,7 @@ async def dispatch_parallel(
                 "success": False,
                 "result": "",
                 "error": str(res),
+                "error_type": "cli_error",
             })
         else:
             output.append(res)
@@ -421,16 +423,22 @@ async def dispatch_stream(
         # Forward progress messages while the subprocess runs
         while not future.done():
             await asyncio.sleep(0.1)
-            while not progress_queue.empty():
-                msg = progress_queue.get_nowait()
+            while True:
+                try:
+                    msg = progress_queue.get_nowait()
+                except queue.Empty:
+                    break
                 if ctx:
                     await ctx.info(f"[{agent}] {msg[:300]}")
 
         result = await asyncio.wrap_future(future)
 
         # Drain any remaining messages
-        while not progress_queue.empty():
-            msg = progress_queue.get_nowait()
+        while True:
+            try:
+                msg = progress_queue.get_nowait()
+            except queue.Empty:
+                break
             if ctx:
                 await ctx.info(f"[{agent}] {msg[:300]}")
 
@@ -642,7 +650,7 @@ async def add_agent(
         directory: Absolute path to the project directory.
         description: What this agent can do. Leave empty for auto-generation.
         timeout: Timeout in seconds (0 uses global default of 300).
-        max_budget_usd: Max cost in USD per dispatch (0 = no limit).
+        max_budget_usd: Max cost in USD per dispatch (0 or omitted = no limit).
         permission_mode: Permission mode for the claude CLI
             (e.g. default, plan, bypassPermissions). Leave empty for default.
         allowed_tools: Comma-separated list of allowed tools
@@ -666,8 +674,17 @@ async def add_agent(
         return json.dumps({"error": f"Agent '{name}' already exists. Remove it first."})
 
     desc = description or auto_describe(dir_path)
-    parsed_allowed = [t.strip() for t in allowed_tools.split(",") if t.strip()] if allowed_tools else []
-    parsed_disallowed = [t.strip() for t in disallowed_tools.split(",") if t.strip()] if disallowed_tools else []
+    parsed_allowed = (
+        [t.strip() for t in allowed_tools.split(",") if t.strip()]
+        if allowed_tools else None
+    )
+    parsed_disallowed = (
+        [t.strip() for t in disallowed_tools.split(",") if t.strip()]
+        if disallowed_tools else None
+    )
+
+    if ctx and (warning := check_permission_mode(permission_mode or None)):
+        await ctx.info(f"Warning: {warning}")
 
     config.agents[name] = AgentConfig(
         directory=dir_path,
@@ -681,8 +698,6 @@ async def add_agent(
     save_config(config)
 
     if ctx:
-        if warning := check_permission_mode(permission_mode or None):
-            await ctx.info(f"Warning: {warning}")
         await ctx.info(f"Added agent '{name}' -> {dir_path}")
 
     result: dict = {
@@ -746,8 +761,8 @@ async def update_agent(
         name: Agent name to update.
         description: New description.
         timeout: New timeout in seconds (0 = don't change).
-        max_budget_usd: Max cost in USD per dispatch (0 = don't change,
-            negative = clear limit).
+        max_budget_usd: New max cost in USD per dispatch (0 = don't change;
+            pass a negative number to clear the limit).
         model: Model override. Pass "none" to clear.
         permission_mode: Permission mode. Pass "none" to clear.
         allowed_tools: Comma-separated allowed tools. Pass "none" to clear.
@@ -781,13 +796,13 @@ async def update_agent(
         updated.append("permission_mode")
     if allowed_tools:
         if allowed_tools.lower() == "none":
-            agent.allowed_tools = []
+            agent.allowed_tools = None
         else:
             agent.allowed_tools = [t.strip() for t in allowed_tools.split(",") if t.strip()]
         updated.append("allowed_tools")
     if disallowed_tools:
         if disallowed_tools.lower() == "none":
-            agent.disallowed_tools = []
+            agent.disallowed_tools = None
         else:
             agent.disallowed_tools = [
                 t.strip() for t in disallowed_tools.split(",") if t.strip()