delete_rewrite

Instructions

Implementation Reference

• migadu_mcp/tools/rewrite_tools.py:74-82 (handler)

  Tool handler function for delete_rewrite. Decorated with @migadu_bulk_tool, accepts a RewriteDeleteRequest, resolves domain, calls the service layer, and returns success.

  @migadu_bulk_tool(mcp, RewriteDeleteRequest, entity="rewrite", destructive=True)
  async def delete_rewrite(
      item: RewriteDeleteRequest, ctx: Context
  ) -> dict[str, Any]:
      """Delete rewrite rule(s). DESTRUCTIVE. List of dicts with: name, domain (optional)."""
      domain = item.domain or resolve_domain(None)
      await ctx.warning(f"🗑️ Deleting rewrite {item.name}")
      await get_service_factory().rewrite_service().delete_rewrite(domain, item.name)
      return {"deleted": item.name, "success": True}

• migadu_mcp/services/rewrite_service.py:59-60 (handler)

  Service-layer implementation that sends the actual HTTP DELETE request to the Migadu API endpoint /domains/{domain}/rewrites/{name}

  async def delete_rewrite(self, domain: str, name: str) -> None:
      await self.client.delete(f"/domains/{domain}/rewrites/{name}")

• migadu_mcp/utils/schemas.py:219-222 (schema)

  Pydantic schema defining the input validation for delete_rewrite: requires 'name' (str), optional 'domain' (str)

  class RewriteDeleteRequest(BaseModel):
      name: str
      domain: str | None = None

• migadu_mcp/main.py:56-56 (registration)

  Registration of rewrite tools in the initialize_server function of main.py, which calls register_rewrite_tools(mcp)

  register_rewrite_tools(mcp)

• migadu_mcp/tools/rewrite_tools.py:16-84 (registration)

  The register_rewrite_tools function that registers all rewrite tools including delete_rewrite with FastMCP via the @migadu_bulk_tool decorator

  def register_rewrite_tools(mcp: FastMCP) -> None:
      @migadu_tool(mcp, read_only=True, summarize_response=True)
      async def list_rewrites(ctx: Context, domain: str | None = None) -> dict[str, Any]:
          """List rewrite rules for a domain."""
          resolved = resolve_domain(domain)
          await ctx.info(f"📋 Listing rewrites for {resolved}")
          return await get_service_factory().rewrite_service().list_rewrites(resolved)
  
      @migadu_tool(mcp, read_only=True)
      async def get_rewrite(
          name: str, ctx: Context, domain: str | None = None
      ) -> dict[str, Any]:
          """Get rewrite rule details by slug/name."""
          resolved = resolve_domain(domain)
          await ctx.info(f"📋 Getting rewrite {name} for {resolved}")
          return await get_service_factory().rewrite_service().get_rewrite(resolved, name)
  
      @migadu_bulk_tool(mcp, RewriteCreateRequest, entity="rewrite", idempotent=False)
      async def create_rewrite(
          item: RewriteCreateRequest, ctx: Context
      ) -> dict[str, Any]:
          """Create rewrite rule(s). List of dicts with: name, local_part_rule (pattern), destinations, domain (optional), order_num (optional)."""
          domain = item.domain or resolve_domain(None)
          destinations = [str(d) for d in item.destinations]
          await ctx.info(f"📋 Creating rewrite {item.name} on {domain}")
          result = (
              await get_service_factory()
              .rewrite_service()
              .create_rewrite(
                  domain, item.name, item.local_part_rule, destinations, item.order_num
              )
          )
          return {"rewrite": result, "success": True}
  
      @migadu_bulk_tool(mcp, RewriteUpdateRequest, entity="rewrite")
      async def update_rewrite(
          item: RewriteUpdateRequest, ctx: Context
      ) -> dict[str, Any]:
          """Update rewrite rule(s). List of dicts with: name (required), and any of: new_name, local_part_rule, destinations, order_num, domain."""
          domain = item.domain or resolve_domain(None)
          destinations = (
              [str(d) for d in item.destinations] if item.destinations else None
          )
          await ctx.info(f"📋 Updating rewrite {item.name} on {domain}")
          result = (
              await get_service_factory()
              .rewrite_service()
              .update_rewrite(
                  domain,
                  item.name,
                  item.new_name,
                  item.local_part_rule,
                  destinations,
                  item.order_num,
              )
          )
          return {"rewrite": result, "success": True}
  
      @migadu_bulk_tool(mcp, RewriteDeleteRequest, entity="rewrite", destructive=True)
      async def delete_rewrite(
          item: RewriteDeleteRequest, ctx: Context
      ) -> dict[str, Any]:
          """Delete rewrite rule(s). DESTRUCTIVE. List of dicts with: name, domain (optional)."""
          domain = item.domain or resolve_domain(None)
          await ctx.warning(f"🗑️ Deleting rewrite {item.name}")
          await get_service_factory().rewrite_service().delete_rewrite(domain, item.name)
          return {"deleted": item.name, "success": True}
  
      _ = (list_rewrites, get_rewrite, create_rewrite, update_rewrite, delete_rewrite)